Changeset 1875


Ignore:
Timestamp:
05/12/20 11:52:13 (3 months ago)
Author:
ymipsl
Message:

XIOS coupling branch
Some updates.

First coupling test is beginning to work...

YM

Location:
XIOS/dev/dev_ym/XIOS_COUPLING
Files:
1 added
42 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/dev_ym/XIOS_COUPLING/arch/arch-X64_IRENE.env

    r1649 r1875  
    77module load blitz 
    88module load feature/bridge/heterogenous_mpmd 
     9 
     10module load totalview 
  • XIOS/dev/dev_ym/XIOS_COUPLING/bld.cfg

    r1510 r1875  
    3838src::xios::transformation::Functions    $PWD/src/transformation/Functions 
    3939src::xios::type                         $PWD/src/type 
     40src::xios::manager                      $PWD/src/manager 
     41 
    4042 
    4143src::netcdf $PWD/extern/netcdf4 
     
    4648#bld::target test_remap.exe 
    4749bld::target xios_server.exe  
     50bld::target generic_testcase.exe  
    4851#bld::target test_regular.exe 
    4952#bld::target test_xios2_cmip6.exe 
  • XIOS/dev/dev_ym/XIOS_COUPLING/make_xios

    r1510 r1875  
    1111use_extern_blitz="false" 
    1212use_memtrack="false" 
     13use_tv="false" 
    1314job="1" 
    1415netcdf_lib="netcdf4_par" 
     
    3435            echo "       [--full] : to generate dependencies and recompile from scratch" 
    3536            echo "       [--use_oasis 'oasis3' 'oasis3_mct' : default oasis3_mct] : to use Oasis coupler" 
    36         echo "       [--build_path : absolute path to the build directory" 
    37         echo "       [--build_dir : name of the build directory" 
    38         echo "       [--build_suffixed : generate automatically suffixed name of the build directory (e.g. config_X64_CURIE_prod)" 
    39         echo "       [--use_extern_boost : to use external boost library" 
    40         echo "       [--use_extern_blitz : to use external blitz library" 
     37        echo "       [--build_path] : absolute path to the build directory" 
     38        echo "       [--build_dir ]: name of the build directory" 
     39        echo "       [--build_suffixed ]: generate automatically suffixed name of the build directory (e.g. config_X64_CURIE_prod)" 
     40        echo "       [--use_extern_boost] : to use external boost library" 
     41        echo "       [--use_extern_blitz] : to use external blitz library" 
     42        echo "       [--use_tv] : to use totalview data type display" 
    4143            echo "       [--doc] : to generate Doxygen documentation (not available yet)" 
    4244            echo "       [--job ntasks] : to use parallel compilation with ntasks" 
     
    5961         "--use_extern_boost")  use_extern_boost="true" ; shift  ;; 
    6062         "--use_extern_blitz")  use_extern_blitz="true" ; shift  ;; 
     63         "--use_tv")  use_tv="true" ; shift  ;; 
    6164         "--doc")   doc="true"          ; shift ;; 
    6265         "--job")   job=$2              ; shift ; shift ;; 
     
    233236fi 
    234237 
     238if [[ "$use_tv" == "true" ]] 
     239then 
     240   echo "src::tv_data_display $PWD/extern/tv_data_display" >> ${PWD}/bld_dir.cfg 
     241fi 
     242 
    235243 
    236244if [[ "$use_memtrack" == "true" ]] 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/array_new.hpp

    r1622 r1875  
    77#include "buffer_out.hpp" 
    88#include "message.hpp" 
     9#include "tv_data_display.h" 
     10#ifdef __GNUC__ 
     11#include <typeinfo> 
     12#include <cxxabi.h> 
     13#endif 
    914#include <cmath> 
    1015 
    1116using namespace blitz; 
    1217BZ_DECLARE_FUNCTION(round) 
     18 
     19namespace xios 
     20{ 
     21  template <typename T_numtype,int N_rank> 
     22  class CArray ; 
     23 
     24 template <typename T_numtype,int N_rank> 
     25 int TV_ttf_display_type ( const CArray<T_numtype, N_rank>* array ) ; 
     26} 
     27 
     28template <typename T_numtype,int N_rank> 
     29int TV_ttf_display_type ( const xios::CArray<T_numtype, N_rank>* array ) ; 
    1330 
    1431namespace xios 
     
    1936    private: 
    2037      bool initialized; 
    21  
     38      void inc_symbol(void) 
     39      { 
     40        TV_ttf_display_type(this); 
     41      } 
    2242    public: 
    2343      typedef typename Array<T_numtype,N_rank>::T_default_storage T_default_storage; 
     
    2747        : Array<T_numtype,N_rank>(expr) 
    2848        , initialized(true) 
    29       {} 
     49      { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol(); } 
    3050 
    3151      CArray(GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    3252        : Array<T_numtype,N_rank>(storage) 
    3353        , initialized(false) 
    34       {} 
     54      { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    3555 
    3656      explicit CArray(int length0, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    3757        : Array<T_numtype,N_rank>(length0, storage) 
    3858        , initialized(true) 
    39       {} 
     59      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    4060 
    4161      CArray(int length0, int length1, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    4262        : Array<T_numtype,N_rank>(length0, length1, storage) 
    4363        , initialized(true) 
    44       {} 
     64      { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    4565 
    4666      CArray(int length0, int length1, int length2, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    4767        : Array<T_numtype,N_rank>(length0, length1, length2, storage) 
    4868        , initialized(true) 
    49       {} 
     69      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    5070 
    5171      CArray(int length0, int length1, int length2, int length3, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    5272        : Array<T_numtype,N_rank>(length0, length1, length2, length3, storage) 
    5373        , initialized(true) 
    54       {} 
     74      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    5575 
    5676      CArray(int length0, int length1, int length2, int length3, int length4, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    5777        : Array<T_numtype,N_rank>(length0,length1, length2, length3, length4, storage) 
    5878        , initialized(true) 
    59       {} 
     79      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    6080 
    6181      CArray(int length0, int length1, int length2, int length3, int length4, int length5, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    6282        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, storage) 
    6383        , initialized(true) 
    64       {} 
     84      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    6585 
    6686      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    6787        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, storage) 
    6888        , initialized(true) 
    69       {} 
     89      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    7090 
    7191      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, int length7, 
     
    7393        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, storage) 
    7494        , initialized(true) 
    75       {} 
     95      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    7696 
    7797      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, 
     
    7999       : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, storage) 
    80100       , initialized(true) 
    81       {} 
     101      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    82102 
    83103      CArray(int length0, int length1, int length2, int length3, int length4, 
     
    85105        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, length9, storage) 
    86106        , initialized(true) 
    87       {} 
     107      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    88108 
    89109      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, 
     
    91111       : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, length9, length10, storage) 
    92112       , initialized(true) 
    93       {} 
     113      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    94114 
    95115      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    96116        : Array<T_numtype,N_rank>(dataFirst, shape, storage) 
    97117        , initialized(true) 
    98       {} 
     118      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    99119 
    100120      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, TinyVector<diffType, N_rank> stride, 
     
    102122        : Array<T_numtype,N_rank>(dataFirst, shape, stride, storage) 
    103123        , initialized(true) 
    104       {} 
     124      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    105125 
    106126      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, preexistingMemoryPolicy deletionPolicy, 
     
    108128        : Array<T_numtype,N_rank>(dataFirst, shape, deletionPolicy, storage) 
    109129        , initialized(true) 
    110       {} 
     130      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    111131 
    112132      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, TinyVector<diffType, N_rank> stride, 
     
    114134        : Array<T_numtype,N_rank>(dataFirst, shape, stride, deletionPolicy, storage) 
    115135        , initialized(true) 
    116       {} 
     136      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    117137 
    118138      CArray(const TinyVector<int, N_rank>& extent, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    119139        : Array<T_numtype,N_rank>(extent, storage) 
    120140        , initialized(true) 
    121       {} 
     141      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    122142 
    123143      CArray(const TinyVector<int, N_rank>& lbounds, const TinyVector<int, N_rank>& extent, 
     
    125145        : Array<T_numtype,N_rank>(lbounds, extent, storage) 
    126146        , initialized(true) 
    127       {} 
     147      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    128148 
    129149      CArray(Range r0, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    130150        : Array<T_numtype,N_rank>(r0, storage) 
    131151        , initialized(true) 
    132       {} 
     152      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    133153 
    134154      CArray(Range r0, Range r1, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    135155        : Array<T_numtype,N_rank>(r0, r1, storage) 
    136156        , initialized(true) 
    137       {} 
     157      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    138158 
    139159      CArray(Range r0, Range r1, Range r2, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    140160        : Array<T_numtype,N_rank>(r0, r1, r2, storage) 
    141161        , initialized(true) 
    142       {} 
     162      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    143163 
    144164      CArray(Range r0, Range r1, Range r2, Range r3, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    145165        : Array<T_numtype,N_rank>(r0, r1, r2, r3, storage) 
    146166        , initialized(true) 
    147       {} 
     167      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    148168 
    149169      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    150170        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, storage) 
    151171        , initialized(true) 
    152       {} 
     172      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    153173 
    154174      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    155175        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, storage) 
    156176        , initialized(true) 
    157       {} 
     177      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    158178 
    159179      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, 
     
    161181        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, storage) 
    162182        , initialized(true) 
    163       {} 
     183      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    164184 
    165185      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, 
     
    167187        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, storage) 
    168188        , initialized(true) 
    169       {} 
     189      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    170190 
    171191      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
     
    173193        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, storage) 
    174194        , initialized(true) 
    175       {} 
     195      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    176196 
    177197      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
     
    179199        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, storage) 
    180200        , initialized(true) 
    181       {} 
     201      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    182202 
    183203      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, 
     
    185205        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, storage) 
    186206        , initialized(true) 
    187       {} 
     207      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    188208 
    189209      CArray(const CArray<T_numtype, N_rank>& array) 
    190210        : Array<T_numtype,N_rank>(array) 
    191211        , initialized(array.initialized) 
    192       {} 
     212      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    193213 
    194214      CArray(const Array<T_numtype, N_rank>& array) 
    195215        : Array<T_numtype,N_rank>(array) 
    196216        , initialized(true) 
    197       {} 
     217      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    198218 
    199219      CArray(const TinyVector<int,N_rank-1>& shape, int lastExtent, const GeneralArrayStorage<N_rank>& storage) 
    200220        : Array<T_numtype,N_rank>(shape, lastExtent, storage) 
    201221        , initialized(true) 
    202       {} 
     222      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    203223 
    204224      CArray(Array<T_numtype, N_rank>& array, Range r0) 
    205225        : Array<T_numtype,N_rank>(array, r0) 
    206226        , initialized(true) 
    207       {} 
     227      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    208228 
    209229      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1) 
    210230        : Array<T_numtype,N_rank>(array, r0, r1) 
    211231        , initialized(true) 
    212       {} 
     232      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    213233 
    214234      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2) 
    215235        : Array<T_numtype,N_rank>( array, r0, r1, r2) 
    216236        , initialized(true) 
    217       {} 
     237      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    218238 
    219239      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3) 
    220240        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3) 
    221241        , initialized(true) 
    222       {} 
     242      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    223243 
    224244      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, 
     
    226246        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3,  r4) 
    227247        , initialized(true) 
    228       {} 
     248      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    229249 
    230250      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, 
     
    232252        : Array<T_numtype,N_rank>( array, r0, r1, r2, r3, r4, r5) 
    233253        , initialized(true) 
    234       {} 
     254      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    235255 
    236256      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, 
     
    238258        : Array<T_numtype,N_rank>( array, r0, r1, r2, r3, r4, r5, r6) 
    239259        , initialized(true) 
    240       {} 
     260      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    241261 
    242262      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, 
     
    244264        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7) 
    245265        , initialized(true) 
    246       {} 
     266      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    247267 
    248268      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
     
    250270        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8) 
    251271        , initialized(true) 
    252       {} 
     272      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    253273 
    254274      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
     
    256276        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9) 
    257277        , initialized(true) 
    258       {} 
     278      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    259279 
    260280      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, 
     
    262282        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10) 
    263283        , initialized(true) 
    264       {} 
     284      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    265285 
    266286      CArray(Array<T_numtype, N_rank>& array, const RectDomain<N_rank>& subdomain) 
    267287        : Array<T_numtype,N_rank>(array, subdomain) 
    268288        , initialized(true) 
    269       {} 
     289      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    270290 
    271291      CArray(Array<T_numtype, N_rank>& array, const StridedDomain<N_rank>& subdomain) 
    272292        : Array<T_numtype,N_rank>(array, subdomain) 
    273293        , initialized(true) 
    274       {} 
     294      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    275295 
    276296      template<int N_rank2, typename R0, typename R1, typename R2, typename R3, typename R4, typename R5, 
     
    279299        : Array<T_numtype,N_rank>(array, r0,r1, r2, r3, r4, r5, r6, r7, r8, r9, r10) 
    280300        , initialized(true) 
    281       {} 
     301      { bool neverTrue ; neverTrue=false ; bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol(); } 
    282302 
    283303      virtual ~CArray() {} 
     
    548568      virtual size_t size(void) const { return size(this->numElements()); } 
    549569      static size_t size(sizeType numElements) { return (N_rank + 1) * sizeof(int) + sizeof(size_t) + numElements * sizeof(T_numtype); } 
    550  
     570       
     571      static int show_TV_ttf_display_type ( const CArray<T_numtype,N_rank>* array ) 
     572      { 
     573        int status ; 
     574        if (array->isEmpty())  
     575        { 
     576          status = TV_ttf_add_row("State", TV_ttf_type_ascii_string,"(empty)") ; 
     577          if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
     578          else return TV_ttf_format_ok_elide ; 
     579        } 
     580        else  
     581        { 
     582          char tname[128] ; 
     583          char bname[128] = "value_type" ; 
     584#ifdef __GNUC__ 
     585         size_t size = sizeof(bname) ; 
     586         abi::__cxa_demangle(typeid(T_numtype).name(), bname, &size, &status) ; 
     587         if (status !=0) return TV_ttf_format_raw ; 
     588#endif 
     589          int dim = array->dimensions() ; 
     590          if (dim==1) snprintf (tname, sizeof(tname), "%s[%d]", bname, array->extent(0)); 
     591          if (dim==2) snprintf (tname, sizeof(tname), "%s[%d][%d]", bname, array->extent(1), array->extent(0)); 
     592          if (dim==3) snprintf (tname, sizeof(tname), "%s[%d][%d][%d]", bname, array->extent(2), array->extent(1), array->extent(3)); 
     593          if (dim==4) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d]", bname, array->extent(0), array->extent(1), array->extent(2), array->extent(3)); 
     594          if (dim==5) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d]", bname, array->extent(4), array->extent(3), array->extent(2), array->extent(1) 
     595                                                                                      ,array->extent(0)); 
     596          if (dim==6) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d][%d]", bname, array->extent(5), array->extent(4), array->extent(3), array->extent(2) 
     597                                                                                      ,array->extent(1),array->extent(0)); 
     598          if (dim==7) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d][%d][%d]", bname, array->extent(6), array->extent(5), array->extent(4), array->extent(3) 
     599                                                                                      ,array->extent(2),array->extent(1),array->extent(0)); 
     600          status = TV_ttf_add_row("array_values", tname, array->dataFirst()) ; 
     601          if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
     602          else return TV_ttf_format_ok ; 
     603        } 
     604      } 
     605       
     606 
     607      static int TV_ttf_display_type ( const CArray<T_numtype,N_rank>* array ) 
     608      { 
     609        return show_TV_ttf_display_type (array) ; 
     610      } 
     611       
    551612      virtual CBaseType* clone(void) const { return new CArray(*this); } 
    552613 
     
    578639        return ret; 
    579640      } 
     641 
    580642  }; 
     643 
     644 
     645#define macrotyperank(_TYPE_,_RANK_)\ 
     646  template<> int CArray<_TYPE_,_RANK_>::TV_ttf_display_type( const CArray<_TYPE_,_RANK_>* array ) \ 
     647  {\ 
     648    return show_TV_ttf_display_type (array) ;\ 
     649  } 
     650 
     651#define macrotype(_TYPE_)\ 
     652macrotyperank(_TYPE_,1)\ 
     653macrotyperank(_TYPE_,2)\ 
     654macrotyperank(_TYPE_,3)\ 
     655macrotyperank(_TYPE_,4)\ 
     656macrotyperank(_TYPE_,5)\ 
     657macrotyperank(_TYPE_,6)\ 
     658macrotyperank(_TYPE_,7) 
     659 
     660macrotype(double) 
     661macrotype(int) 
     662macrotype(bool) 
     663macrotype(size_t) 
     664macrotype(float) 
     665macrotype(string) 
     666 
     667#undef macrotyperank 
     668#undef macrotype 
     669 
    581670 
    582671 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/attribute_array.hpp

    r1622 r1875  
    2121      { 
    2222        public : 
    23  
    24            using CArray<T_numtype,N_rank>::operator = ; 
     23            using CArray<T_numtype,N_rank>::operator = ; 
    2524 
    2625            /// Constructeurs /// 
     
    6564            virtual void generateFortranInterfaceGetBody_(ostream& oss,const string& className) ; 
    6665            virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) ; 
     66  
     67 static int show_TV_ttf_display_type ( const CAttributeArray<T_numtype,N_rank>* array ) 
     68      { 
     69        int status ; 
     70        if (array->isEmpty())  
     71        { 
     72          status = TV_ttf_add_row("State", TV_ttf_type_ascii_string,"(empty)") ; 
     73          if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
     74          else return TV_ttf_format_ok_elide ; 
     75        } 
     76        else  
     77        { 
     78          char tname[128] ; 
     79          char bname[128] = "value_type" ; 
     80#ifdef __GNUC__ 
     81         size_t size = sizeof(bname) ; 
     82         abi::__cxa_demangle(typeid(T_numtype).name(), bname, &size, &status) ; 
     83         if (status !=0) return TV_ttf_format_raw ; 
     84#endif 
     85          int dim = array->dimensions() ; 
     86          if (dim==1) snprintf (tname, sizeof(tname), "%s[%d]", bname, array->extent(0)); 
     87          if (dim==2) snprintf (tname, sizeof(tname), "%s[%d][%d]", bname, array->extent(1), array->extent(0)); 
     88          if (dim==3) snprintf (tname, sizeof(tname), "%s[%d][%d][%d]", bname, array->extent(2), array->extent(1), array->extent(3)); 
     89          if (dim==4) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d]", bname, array->extent(0), array->extent(1), array->extent(2), array->extent(3)); 
     90          if (dim==5) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d]", bname, array->extent(4), array->extent(3), array->extent(2), array->extent(1) 
     91                                                                                      ,array->extent(0)); 
     92          if (dim==6) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d][%d]", bname, array->extent(5), array->extent(4), array->extent(3), array->extent(2) 
     93                                                                                      ,array->extent(1),array->extent(0)); 
     94          if (dim==7) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d][%d][%d]", bname, array->extent(6), array->extent(5), array->extent(4), array->extent(3) 
     95                                                                                      ,array->extent(2),array->extent(1),array->extent(0)); 
     96          status = TV_ttf_add_row("array_values", tname, array->dataFirst()) ; 
     97          if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
     98          else return TV_ttf_format_ok ; 
     99        } 
     100      } 
     101       
     102             
     103            static int TV_ttf_display_type ( const  CAttributeArray<T_numtype,N_rank>* array ) 
     104           { 
     105             return CAttributeArray<T_numtype,N_rank>::show_TV_ttf_display_type (array) ; 
     106           } 
    67107 
    68108         private : 
     
    75115          bool _fromBuffer(CBufferIn& buffer) ; 
    76116      }; // class CAttributeEnum 
     117 
     118 
     119#define macrotyperank(_TYPE_,_RANK_)\ 
     120  template<> int CAttributeArray<_TYPE_,_RANK_>::TV_ttf_display_type(const CAttributeArray<_TYPE_,_RANK_>* array ) \ 
     121  {\ 
     122    return CAttributeArray<_TYPE_,_RANK_>::show_TV_ttf_display_type (array) ;\ 
     123  } 
     124 
     125#define macrotype(_TYPE_)\ 
     126macrotyperank(_TYPE_,1)\ 
     127macrotyperank(_TYPE_,2)\ 
     128macrotyperank(_TYPE_,3)\ 
     129macrotyperank(_TYPE_,4)\ 
     130macrotyperank(_TYPE_,5)\ 
     131macrotyperank(_TYPE_,6)\ 
     132macrotyperank(_TYPE_,7) 
     133 
     134macrotype(double) 
     135macrotype(int) 
     136macrotype(bool) 
     137macrotype(size_t) 
     138macrotype(float) 
     139macrotype(string) 
     140 
     141#undef macrotyperank 
     142#undef macrotype 
    77143} // namespace xios 
    78144 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/attribute_array_impl.hpp

    r1622 r1875  
    1414      CAttributeArray<T_numtype, N_rank>::CAttributeArray(const StdString & id) 
    1515         : CAttribute(id) 
    16       { /* Ne rien faire de plus */ } 
     16      { bool alwaysFalse ; alwaysFalse=false ; if (alwaysFalse) TV_ttf_display_type(this); } 
    1717 
    1818      template <typename T_numtype, int N_rank> 
     
    2020         : CAttribute(id) 
    2121      { 
     22         bool alwaysFalse ; alwaysFalse=false ; if (alwaysFalse) TV_ttf_display_type(this); 
    2223         this->setValue(value); 
    2324      } 
     
    2728         : CAttribute(id) 
    2829      { 
     30         bool alwaysFalse ; alwaysFalse=false ; if (alwaysFalse) TV_ttf_display_type(this); 
    2931         umap.insert(umap.end(), std::make_pair(id, this)); 
    3032      } 
     
    3537         : CAttribute(id) 
    3638      { 
     39         bool alwaysFalse ; alwaysFalse=false ; if (alwaysFalse) TV_ttf_display_type(this); 
    3740         this->setValue(value); 
    3841         umap.insert(umap.end(), std::make_pair(id, this)); 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/attribute_template.hpp

    r1622 r1875  
    1212#include "buffer_out.hpp" 
    1313#include "type.hpp" 
     14#include "tv_data_display.h" 
     15 
     16#ifdef __GNUC__ 
     17#include <typeinfo> 
     18#include <cxxabi.h> 
     19#endif 
    1420 
    1521namespace xios 
     
    2026    The class implements attribute of some basic types 
    2127  */ 
    22       template <class T> 
     28       template <class T> 
    2329         class CAttributeTemplate : public CAttribute, public CType<T> 
    2430      { 
     
    9197//            virtual void generateFortranInterfaceIsDefinedDeclaration(ostream& oss,const string& className) ; 
    9298 
     99           static int show_TV_ttf_display_type ( const CAttributeTemplate<T>* attr) 
     100           { 
     101             int status ; 
     102             if (attr->isEmpty())  
     103             { 
     104               status = TV_ttf_add_row("State", TV_ttf_type_ascii_string,"(empty)") ; 
     105               if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
     106               else return TV_ttf_format_ok_elide ; 
     107             } 
     108             else  
     109             { 
     110               char tname[128] ; 
     111               char bname[128] = "ValueType" ; 
     112#ifdef __GNUC__ 
     113               size_t size = sizeof(bname) ; 
     114               abi::__cxa_demangle(typeid(T).name(), bname, &size, &status) ; 
     115               if (status !=0) return TV_ttf_format_raw ; 
     116#endif 
     117               snprintf (tname, sizeof(tname), "%s", bname); 
     118               if (typeid(T)==typeid(string)) 
     119                 status = TV_ttf_add_row("values", TV_ttf_type_ascii_string, ((string*)(attr->ptrValue))->c_str() ); 
     120               else status = TV_ttf_add_row("values", tname, attr->ptrValue) ; 
     121               if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
     122               else return TV_ttf_format_ok_elide ; 
     123             } 
     124           } 
     125       
     126           static int TV_ttf_display_type ( const CAttributeTemplate<T>* attr ) 
     127           { 
     128             return show_TV_ttf_display_type (attr) ; 
     129           } 
     130 
    93131 
    94132         protected : 
     
    107145      }; // class CAttribute 
    108146 
     147#define macrotype(_TYPE_)\ 
     148  template<> int CAttributeTemplate<_TYPE_>::TV_ttf_display_type( const CAttributeTemplate<_TYPE_>* attr ) \ 
     149  {\ 
     150    return show_TV_ttf_display_type (attr) ;\ 
     151  } 
     152 
     153macrotype(double) 
     154macrotype(int) 
     155macrotype(bool) 
     156macrotype(string) 
     157//macrotype(CDate) 
     158//macrotype(CDuration) 
     159#undef macrotype 
    109160 
    110161   template <class T>  void FromBinary(StdIStream & is, T & obj); 
     162 
    111163 
    112164} // namespace xios 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/buffer_decl.cpp

    r501 r1875  
    1717  macro(short) 
    1818  macro(long) 
     19  macro(longlong) 
    1920  macro(uint) 
    2021  macro(ushort) 
    2122  macro(ulong) 
     23  macro(ulonglong) 
    2224  macro(float) 
    2325  macro(double) 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/buffer_impl.hpp

    r501 r1875  
    1010    template <> bool CBuffer::put<short>(const short& data) { return put_template(data) ; }   
    1111    template <> bool CBuffer::put<long>(const long& data)  { return put_template(data) ; }   
     12    template <> bool CBuffer::put<longlong>(const longlong& data)  { return put_template(data) ; }   
    1213    template <> bool CBuffer::put<uint>(const uint& data)  { return put_template(data) ; }   
    1314    template <> bool CBuffer::put<ushort>(const ushort& data) { return put_template(data) ; }   
    1415    template <> bool CBuffer::put<ulong>(const ulong& data) { return put_template(data) ; }   
     16    template <> bool CBuffer::put<ulonglong>(const ulonglong& data) { return put_template(data) ; }   
    1517    template <> bool CBuffer::put<float>(const float& data) { return put_template(data) ; }   
    1618    template <> bool CBuffer::put<double>(const double& data) { return put_template(data) ; }   
     
    2123    template <> bool CBuffer::put<short>(const short* data, size_t n) { return put_template(data,n) ; }   
    2224    template <> bool CBuffer::put<long>(const long* data, size_t n)  { return put_template(data,n) ; }   
     25    template <> bool CBuffer::put<longlong>(const longlong* data, size_t n)  { return put_template(data,n) ; }   
    2326    template <> bool CBuffer::put<uint>(const uint* data, size_t n)  { return put_template(data,n) ; }   
    2427    template <> bool CBuffer::put<ushort>(const ushort* data, size_t n) { return put_template(data,n) ; }   
    2528    template <> bool CBuffer::put<ulong>(const ulong* data, size_t n) { return put_template(data,n) ; }   
     29    template <> bool CBuffer::put<ulonglong>(const ulonglong* data, size_t n) { return put_template(data,n) ; }   
    2630    template <> bool CBuffer::put<float>(const float* data, size_t n) { return put_template(data,n) ; }   
    2731    template <> bool CBuffer::put<double>(const double* data, size_t n) { return put_template(data,n) ; }   
     
    3337    template <> bool CBuffer::put_ptr<short>(const short*& data, size_t n) { return put_ptr_template(data,n) ; }   
    3438    template <> bool CBuffer::put_ptr<long>(const long*& data, size_t n)  { return put_ptr_template(data,n) ; }   
     39    template <> bool CBuffer::put_ptr<longlong>(const longlong*& data, size_t n)  { return put_ptr_template(data,n) ; }   
    3540    template <> bool CBuffer::put_ptr<uint>(const uint*& data, size_t n)  { return put_ptr_template(data,n) ; }   
    3641    template <> bool CBuffer::put_ptr<ushort>(const ushort*& data, size_t n) { return put_ptr_template(data,n) ; }   
    3742    template <> bool CBuffer::put_ptr<ulong>(const ulong*& data, size_t n) { return put_ptr_template(data,n) ; }   
     43    template <> bool CBuffer::put_ptr<ulonglong>(const ulonglong*& data, size_t n) { return put_ptr_template(data,n) ; }   
    3844    template <> bool CBuffer::put_ptr<float>(const float*& data, size_t n) { return put_ptr_template(data,n) ; }   
    3945    template <> bool CBuffer::put_ptr<double>(const double*& data, size_t n) { return put_ptr_template(data,n) ; }   
     
    4652    template <> bool CBuffer::get<short>(short& data) { return get_template(data) ; }   
    4753    template <> bool CBuffer::get<long>(long& data)  { return get_template(data) ; }   
     54    template <> bool CBuffer::get<longlong>(longlong& data)  { return get_template(data) ; }   
    4855    template <> bool CBuffer::get<uint>(uint& data)  { return get_template(data) ; }   
    4956    template <> bool CBuffer::get<ushort>(ushort& data) { return get_template(data) ; }   
    5057    template <> bool CBuffer::get<ulong>(ulong& data) { return get_template(data) ; }   
     58    template <> bool CBuffer::get<ulonglong>(ulonglong& data) { return get_template(data) ; }   
    5159    template <> bool CBuffer::get<float>(float& data) { return get_template(data) ; }   
    5260    template <> bool CBuffer::get<double>(double& data) { return get_template(data) ; }   
     
    5765    template <> bool CBuffer::get<short>(short* data, size_t n) { return get_template(data,n) ; }   
    5866    template <> bool CBuffer::get<long>(long* data, size_t n)  { return get_template(data,n) ; }   
     67    template <> bool CBuffer::get<longlong>(longlong* data, size_t n)  { return get_template(data,n) ; }   
    5968    template <> bool CBuffer::get<uint>(uint* data, size_t n)  { return get_template(data,n) ; }   
    6069    template <> bool CBuffer::get<ushort>(ushort* data, size_t n) { return get_template(data,n) ; }   
    6170    template <> bool CBuffer::get<ulong>(ulong* data, size_t n) { return get_template(data,n) ; }   
     71    template <> bool CBuffer::get<ulonglong>(ulonglong* data, size_t n) { return get_template(data,n) ; }   
    6272    template <> bool CBuffer::get<float>(float* data, size_t n) { return get_template(data,n) ; }   
    6373    template <> bool CBuffer::get<double>(double* data, size_t n) { return get_template(data,n) ; }   
     
    6878    template <> bool CBuffer::get_ptr<short>(short*& data, size_t n) { return get_ptr_template(data,n) ; }   
    6979    template <> bool CBuffer::get_ptr<long>(long*& data, size_t n)  { return get_ptr_template(data,n) ; }   
     80    template <> bool CBuffer::get_ptr<longlong>(longlong*& data, size_t n)  { return get_ptr_template(data,n) ; }   
    7081    template <> bool CBuffer::get_ptr<uint>(uint*& data, size_t n)  { return get_ptr_template(data,n) ; }   
    7182    template <> bool CBuffer::get_ptr<ushort>(ushort*& data, size_t n) { return get_ptr_template(data,n) ; }   
    7283    template <> bool CBuffer::get_ptr<ulong>(ulong*& data, size_t n) { return get_ptr_template(data,n) ; }   
     84    template <> bool CBuffer::get_ptr<ulonglong>(ulonglong*& data, size_t n) { return get_ptr_template(data,n) ; }   
    7385    template <> bool CBuffer::get_ptr<float>(float*& data, size_t n) { return get_ptr_template(data,n) ; }   
    7486    template <> bool CBuffer::get_ptr<double>(double*& data, size_t n) { return get_ptr_template(data,n) ; }   
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/buffer_in_decl.cpp

    r501 r1875  
    1414  macro(short) 
    1515  macro(long) 
     16  macro(longlong) 
    1617  macro(uint) 
    1718  macro(ushort) 
    1819  macro(ulong) 
     20  macro(ulonglong) 
    1921  macro(float) 
    2022  macro(double) 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/buffer_in_impl.hpp

    r501 r1875  
    1212    template <> bool CBufferIn::get<short>(short& data) { return get_template(data) ; }   
    1313    template <> bool CBufferIn::get<long>(long& data)  { return get_template(data) ; }   
     14    template <> bool CBufferIn::get<longlong>(longlong& data)  { return get_template(data) ; }   
    1415    template <> bool CBufferIn::get<uint>(uint& data)  { return get_template(data) ; }   
    1516    template <> bool CBufferIn::get<ushort>(ushort& data) { return get_template(data) ; }   
    1617    template <> bool CBufferIn::get<ulong>(ulong& data) { return get_template(data) ; }   
     18    template <> bool CBufferIn::get<ulonglong>(ulonglong& data) { return get_template(data) ; }   
    1719    template <> bool CBufferIn::get<float>(float& data) { return get_template(data) ; }   
    1820    template <> bool CBufferIn::get<double>(double& data) { return get_template(data) ; }   
     
    2426    template <> bool CBufferIn::get<short>(short* data, size_t n) { return get_template(data,n) ; }   
    2527    template <> bool CBufferIn::get<long>(long* data, size_t n)  { return get_template(data,n) ; }   
     28    template <> bool CBufferIn::get<longlong>(longlong* data, size_t n)  { return get_template(data,n) ; }   
    2629    template <> bool CBufferIn::get<uint>(uint* data, size_t n)  { return get_template(data,n) ; }   
    2730    template <> bool CBufferIn::get<ushort>(ushort* data, size_t n) { return get_template(data,n) ; }   
    2831    template <> bool CBufferIn::get<ulong>(ulong* data, size_t n) { return get_template(data,n) ; }   
     32    template <> bool CBufferIn::get<ulonglong>(ulonglong* data, size_t n) { return get_template(data,n) ; }   
    2933    template <> bool CBufferIn::get<float>(float* data, size_t n) { return get_template(data,n) ; }   
    3034    template <> bool CBufferIn::get<double>(double* data, size_t n) { return get_template(data,n) ; }   
     
    3640    template <> bool CBufferIn::advance<short>(size_t n) { return advance_template<short>(n) ; }   
    3741    template <> bool CBufferIn::advance<long>(size_t n)  { return advance_template<long>(n) ; }   
     42    template <> bool CBufferIn::advance<longlong>(size_t n)  { return advance_template<longlong>(n) ; }   
    3843    template <> bool CBufferIn::advance<uint>(size_t n)  { return advance_template<uint>(n) ; }   
    3944    template <> bool CBufferIn::advance<ushort>(size_t n) { return advance_template<ushort>(n) ; }   
    4045    template <> bool CBufferIn::advance<ulong>(size_t n) { return advance_template<ulong>(n) ; }   
     46    template <> bool CBufferIn::advance<ulonglong>(size_t n) { return advance_template<ulonglong>(n) ; }   
    4147    template <> bool CBufferIn::advance<float>(size_t n) { return advance_template<float>(n) ; }   
    4248    template <> bool CBufferIn::advance<double>(size_t n) { return advance_template<double>(n) ; }   
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/buffer_out_decl.cpp

    r501 r1875  
    1515  macro(short) 
    1616  macro(long) 
     17  macro(longlong) 
    1718  macro(uint) 
    1819  macro(ushort) 
    1920  macro(ulong) 
     21  macro(ulonglong) 
    2022  macro(float) 
    2123  macro(double) 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/buffer_out_impl.hpp

    r501 r1875  
    1111    template <> bool CBufferOut::put<short>(const short& data) { return put_template(data) ; }   
    1212    template <> bool CBufferOut::put<long>(const long& data)  { return put_template(data) ; }   
     13    template <> bool CBufferOut::put<longlong>(const longlong& data)  { return put_template(data) ; }   
    1314    template <> bool CBufferOut::put<uint>(const uint& data)  { return put_template(data) ; }   
    1415    template <> bool CBufferOut::put<ushort>(const ushort& data) { return put_template(data) ; }   
    1516    template <> bool CBufferOut::put<ulong>(const ulong& data) { return put_template(data) ; }   
     17    template <> bool CBufferOut::put<ulonglong>(const ulonglong& data) { return put_template(data) ; }   
    1618    template <> bool CBufferOut::put<float>(const float& data) { return put_template(data) ; }   
    1719    template <> bool CBufferOut::put<double>(const double& data) { return put_template(data) ; }   
     
    2325    template <> bool CBufferOut::put<short>(const short* data, size_t n) { return put_template(data,n) ; }   
    2426    template <> bool CBufferOut::put<long>(const long* data, size_t n)  { return put_template(data,n) ; }   
     27    template <> bool CBufferOut::put<longlong>(const longlong* data, size_t n)  { return put_template(data,n) ; }   
    2528    template <> bool CBufferOut::put<uint>(const uint* data, size_t n)  { return put_template(data,n) ; }   
    2629    template <> bool CBufferOut::put<ushort>(const ushort* data, size_t n) { return put_template(data,n) ; }   
    2730    template <> bool CBufferOut::put<ulong>(const ulong* data, size_t n) { return put_template(data,n) ; }   
     31    template <> bool CBufferOut::put<ulonglong>(const ulonglong* data, size_t n) { return put_template(data,n) ; }   
    2832    template <> bool CBufferOut::put<float>(const float* data, size_t n) { return put_template(data,n) ; }   
    2933    template <> bool CBufferOut::put<double>(const double* data, size_t n) { return put_template(data,n) ; }   
     
    3640    template <> bool CBufferOut::advance<short>(size_t n) { return advance_template<short>(n) ; }   
    3741    template <> bool CBufferOut::advance<long>(size_t n)  { return advance_template<long>(n) ; }   
     42    template <> bool CBufferOut::advance<longlong>(size_t n)  { return advance_template<longlong>(n) ; }   
    3843    template <> bool CBufferOut::advance<uint>(size_t n)  { return advance_template<uint>(n) ; }   
    3944    template <> bool CBufferOut::advance<ushort>(size_t n) { return advance_template<ushort>(n) ; }   
    4045    template <> bool CBufferOut::advance<ulong>(size_t n) { return advance_template<ulong>(n) ; }   
     46    template <> bool CBufferOut::advance<ulonglong>(size_t n) { return advance_template<ulonglong>(n) ; }   
    4147    template <> bool CBufferOut::advance<float>(size_t n) { return advance_template<float>(n) ; }   
    4248    template <> bool CBufferOut::advance<double>(size_t n) { return advance_template<double>(n) ; }   
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/context_server.cpp

    r1853 r1875  
    326326         // The best way to properly solve this problem will be to use the event scheduler also in attached mode 
    327327         // for now just set up a MPI barrier 
    328          if (!eventScheduler_ && CXios::isServer) MPI_Barrier(intraComm) ; 
     328//ym to be check later 
     329//         if (!eventScheduler_ && CXios::isServer) MPI_Barrier(intraComm) ; 
    329330 
    330331//         context->setProcessingEvent() ; 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/declare_attribute.hpp

    r1229 r1875  
    4242      public :                                                    \ 
    4343         using CAttributeArray<T_num, T_rank>::operator = ;       \ 
    44          name##_attr(void) : CAttributeArray<T_num, T_rank> (#name, *CAttributeMap::Current) {} \ 
     44         bool alwaysFalse=false;\ 
     45         name##_attr(void) : CAttributeArray<T_num, T_rank> (#name, *CAttributeMap::Current) {if (alwaysFalse) TV_ttf_display_type(this);} \ 
    4546         virtual bool doSend() const { return helper(__VA_ARGS__); }   \ 
    4647         bool helper(bool returnTrue=true) const { return returnTrue; }   \ 
     48         static int TV_ttf_display_type ( const name##_attr* array )\ 
     49         {\ 
     50           cout<<"TV_ttf_display_type"<<endl ;\ 
     51           return CArray<T_num,T_rank>::TV_ttf_display_type((const CArray<T_num,T_rank>*)array) ;\ 
     52         }\ 
    4753         virtual ~name##_attr(void) {}                            \ 
    4854   } name; 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/filter/file_writer_filter.cpp

    r1853 r1875  
    3535    } 
    3636 
    37     field->sendUpdateData(dataArray, client_); 
     37    field->sendUpdateData(data[0]->timestamp, dataArray, client_); 
    3838  } 
    3939 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/filter/spatial_transform_filter.cpp

    r1869 r1875  
    174174        gridTransformation->computeAll(dataAuxInputs, packet->timestamp); 
    175175      } 
    176       packet->data.resize(gridTransformation->getGridDestination()->getDataSize()); 
     176      packet->data.resize(gridTransformation->getGridDestination()->getLocalDataSize()); 
    177177      if (0 != packet->data.numElements()) 
    178178        (packet->data)(0) = defaultValue; 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/group_template.hpp

    r1784 r1875  
    7272         void addChildGroup(V* childGroup) ;  
    7373         static bool dispatchEvent(CEventServer& event) ; 
    74          void sendCreateChild(const string& id, CContextClient* client) ; 
    75          void sendCreateChildGroup(const string& id, CContextClient* client) ; 
     74         void sendCreateChild(const string& id, CContextClient* client, const string& objectId="") ; 
     75         void sendCreateChildGroup(const string& id, CContextClient* client, const string& objectId="") ; 
    7676         static void recvCreateChild(CEventServer& event) ; 
    7777         void recvCreateChild(CBufferIn& buffer) ; 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/group_template_impl.hpp

    r1784 r1875  
    370370 
    371371   template <class U, class V, class W> 
    372    void CGroupTemplate<U, V, W>::sendCreateChild(const string& id, CContextClient* client) 
     372   void CGroupTemplate<U, V, W>::sendCreateChild(const string& id, CContextClient* client, const string& objectId) 
    373373   { 
    374374 
     
    377377    { 
    378378      CMessage msg ; 
    379       msg<<this->getId() ; 
     379      if (objectId.empty()) msg << this->getId(); 
     380      else msg << objectId; 
    380381      msg<<id ; 
    381382      const std::list<int>& ranks = client->getRanksServerLeader(); 
     
    388389 
    389390   template <class U, class V, class W> 
    390    void CGroupTemplate<U, V, W>::sendCreateChildGroup(const string& id, CContextClient* client) 
     391   void CGroupTemplate<U, V, W>::sendCreateChildGroup(const string& id, CContextClient* client, const string& objectId) 
    391392   { 
    392393     CEventClient event(this->getType(),EVENT_ID_CREATE_CHILD_GROUP) ; 
     
    394395     { 
    395396       CMessage msg ; 
    396        msg<<this->getId() ; 
     397       if (objectId.empty()) msg << this->getId(); 
     398       else msg << objectId; 
    397399       msg<<id ; 
    398400       const std::list<int>& ranks = client->getRanksServerLeader(); 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/axis.cpp

    r1872 r1875  
    575575   } 
    576576 
     577   void CAxis::sendAxisToCouplerOut(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, const string& fieldId, int posInGrid) 
     578   { 
     579     if (sendAxisToFileServer_done_.count(client)!=0) return ; 
     580     else sendAxisToFileServer_done_.insert(client) ; 
     581      
     582     string axisId="_axis["+std::to_string(posInGrid)+"]_of_"+fieldId ; 
     583 
     584     if (!axis_ref.isEmpty()) 
     585    { 
     586      auto axis_ref_tmp=axis_ref.getValue() ; 
     587      axis_ref.reset() ; // remove the reference, find an other way to do that more cleanly 
     588      this->sendAllAttributesToServer(client, axisId)  ;  
     589      axis_ref = axis_ref_tmp ; 
     590    } 
     591    else this->sendAllAttributesToServer(client, axisId)  ;  
     592   
     593    this->sendAttributes(client, globalDim, orderPositionInGrid, CServerDistributionDescription::BAND_DISTRIBUTION, axisId) ; 
     594   } 
     595 
     596  void CAxis::makeAliasForCoupling(const string& fieldId, int posInGrid) 
     597  { 
     598    const string axisId = "_axis["+std::to_string(posInGrid)+"]_of_"+fieldId ; 
     599    this->createAlias(axisId) ; 
     600  } 
     601 
    577602  /*! 
    578603    Send attributes from one client to other clients 
     
    581606  */ 
    582607  void CAxis::sendAttributes(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, 
    583                              CServerDistributionDescription::ServerDistributionType distType) 
    584   TRY 
    585   { 
    586      sendDistributionAttribute(client, globalDim, orderPositionInGrid, distType); 
     608                             CServerDistributionDescription::ServerDistributionType distType, const string& axisId) 
     609  TRY 
     610  { 
     611     sendDistributionAttribute(client, globalDim, orderPositionInGrid, distType, axisId); 
    587612 
    588613     // if (index.numElements() == n_glo.getValue()) 
     
    590615         || (index.numElements() != n_glo)) 
    591616     { 
    592        sendDistributedAttributes(client);        
     617       sendDistributedAttributes(client, axisId);        
    593618     } 
    594619     else 
    595620     { 
    596        sendNonDistributedAttributes(client);     
     621       sendNonDistributedAttributes(client, axisId);     
    597622     }      
    598623  } 
     
    889914  */ 
    890915  void CAxis::sendDistributionAttribute(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, 
    891                                         CServerDistributionDescription::ServerDistributionType distType) 
    892   TRY 
    893   { 
     916                                        CServerDistributionDescription::ServerDistributionType distType, const string& axisId) 
     917  TRY 
     918  { 
     919    string serverAxisId = axisId.empty() ? this->getId() : axisId ;  
    894920    int nbServer = client->serverSize; 
    895921 
     
    914940        msgs.push_back(CMessage()); 
    915941        CMessage& msg = msgs.back(); 
    916         msg << this->getId(); 
     942        msg << serverAxisId; 
    917943        msg << ni << begin; 
    918944        msg << isCompressible_;                     
     
    962988    In the future, if new attributes are added, they should also be processed in this function 
    963989  */ 
    964   void CAxis::sendNonDistributedAttributes(CContextClient* client) 
    965   TRY 
    966   { 
     990  void CAxis::sendNonDistributedAttributes(CContextClient* client, const string& axisId) 
     991  TRY 
     992  { 
     993    string serverAxisId = axisId.empty() ? this->getId() : axisId ;  
     994 
    967995    CEventClient event(getType(), EVENT_ID_NON_DISTRIBUTED_ATTRIBUTES); 
    968996    size_t nbIndex = index.numElements(); 
     
    9961024        msgs.push_back(CMessage()); 
    9971025        CMessage& msg = msgs.back(); 
    998         msg << this->getId(); 
     1026        msg << serverAxisId; 
    9991027        msg << index.getValue() << dataIndex << mask.getValue(); 
    10001028        msg << hasValue; 
     
    10871115    In future, if new attributes are added, they should also be processed in this function 
    10881116  */ 
    1089   void CAxis::sendDistributedAttributes(CContextClient* client) 
    1090   TRY 
    1091   { 
     1117  void CAxis::sendDistributedAttributes(CContextClient* client, const string& axisId) 
     1118  TRY 
     1119  { 
     1120    string serverAxisId = axisId.empty() ? this->getId() : axisId ;  
     1121     
    10921122    int ind, idx; 
    10931123    int nbServer = client->serverSize; 
     
    11661196 
    11671197      listData.push_back(CMessage()); 
    1168       listData.back() << this->getId() 
     1198      listData.back() << serverAxisId 
    11691199                      << list_indi.back() << list_dataInd.back(); 
    11701200 
     
    14311461  CATCH_DUMP_ATTR 
    14321462 
    1433 /*! 
    1434   \brief Check if a axis is completed 
    1435   Before make any axis processing, we must be sure that all axis informations have 
    1436   been sent, for exemple when reading a grid in a file or when grid elements are sent by an 
    1437   other context (coupling). So all direct reference of the axis (axis_ref) must be also completed 
    1438   \return true if axis and axis reference are completed 
    1439   */ 
    1440   bool CAxis::checkIfCompleted(void) 
    1441   { 
    1442     if (hasDirectAxisReference()) if (!getDirectAxisReference()->checkIfCompleted()) return false; 
    1443     return isCompleted_ ; 
    1444   } 
    1445  
    1446   /*! 
    1447   \brief Set a axis as completed 
    1448    When all information about a axis have been received, the axis is tagged as completed and is 
    1449    suitable for processing 
    1450   */ 
    1451   void CAxis::setCompleted(void) 
    1452   { 
    1453     if (hasDirectAxisReference()) getDirectAxisReference()->setCompleted() ; 
    1454     isCompleted_=true ; 
    1455   } 
    1456  
    1457   /*! 
    1458   \brief Set a axis as uncompleted 
    1459    When informations about a axis are expected from a grid reading from file or coupling, the axis is  
    1460    tagged as uncompleted and is not suitable for processing 
    1461   */ 
    1462   void CAxis::setUncompleted(void) 
    1463   { 
    1464     if (hasDirectAxisReference()) getDirectAxisReference()->setUncompleted() ; 
    1465     isCompleted_=false ; 
    1466   } 
    1467  
    1468  
    1469  
    14701463  /*! 
    14711464   * Go through the hierarchy to find the axis from which the transformations must be inherited 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/axis.hpp

    r1870 r1875  
    124124         bool isEqual(CAxis* axis); 
    125125 
    126          bool checkIfCompleted(void) ; 
    127          void setCompleted(void) ; 
    128          void setUncompleted(void) ; 
    129  
    130126      public:  
    131127        bool hasValue;         
     
    150146         std::set<CContextClient*> sendAxisToFileServer_done_ ; 
    151147       
     148      public: 
     149         void sendAxisToCouplerOut(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, const string& fieldId, int posInGrid) ; 
     150      private: 
     151         std::set<CContextClient*> sendAxisToCouplerOut_done_ ; 
     152     
     153      public: 
     154         void makeAliasForCoupling(const string& fieldId, int posInGrid) ; 
     155 
    152156      private: 
    153157         void sendAttributes(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, 
    154                              CServerDistributionDescription::ServerDistributionType distType); 
     158                             CServerDistributionDescription::ServerDistributionType distType, const string& axisId=""); 
    155159         void sendDistributionAttribute(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, 
    156                                         CServerDistributionDescription::ServerDistributionType distType); 
    157           
    158  
    159          void sendNonDistributedAttributes(CContextClient* client); 
    160          void sendDistributedAttributes(CContextClient* client); 
     160                                        CServerDistributionDescription::ServerDistributionType distType, const string& axisId=""); 
     161          
     162 
     163         void sendNonDistributedAttributes(CContextClient* client, const string& axisId=""); 
     164         void sendDistributedAttributes(CContextClient* client, const string& axisId=""); 
    161165 
    162166         static void recvNonDistributedAttributes(CEventServer& event); 
     
    171175      private: 
    172176 
    173 /** Clients that have to send a domain. There can be multiple clients in case of secondary server, otherwise only one client. */ 
     177/** Clients that have to send a axis. There can be multiple clients in case of secondary server, otherwise only one client. */ 
    174178         std::list<CContextClient*> clients; 
    175179         std::set<CContextClient*> clientsSet; 
    176180 
     181      private: 
    177182         /** define if the axis is completed or not ie all attributes have been received before in case  
    178183             of grid reading from file or coupling */  
    179184         bool isCompleted_=true ;   
    180  
     185      public:      
     186         /*! 
     187           \brief Check if a axis is completed 
     188           Before make any axis processing, we must be sure that all axis informations have 
     189           been sent, for exemple when reading a grid in a file or when grid elements are sent by an 
     190           other context (coupling). So all direct reference of the axis (axis_ref) must be also completed 
     191           \return true if axis and axis reference are completed 
     192          */ 
     193         bool isCompleted(void) 
     194         { 
     195           if (hasDirectAxisReference()) if (!getDirectAxisReference()->isCompleted()) return false; 
     196           else return isCompleted_ ; 
     197         } 
     198         void setCompleted(void) { isCompleted_=true ; } 
     199         void unsetCompleted(void) { isCompleted_=false ; } 
     200       
     201      private: 
    181202         bool isChecked; 
    182203         bool areClientAttributesChecked_; 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/context.cpp

    r1872 r1875  
    708708    } 
    709709 
    710     for (auto it=couplerClient_.begin(); it!=couplerClient_.end(); ++it) 
    711     { 
    712       if (!finalized) it->second->checkBuffers(); 
    713     } 
    714  
    715     for (auto it=couplerServer_.begin(); it!=couplerServer_.end(); ++it) 
    716     { 
    717       if (!finalized) it->second->eventLoop(enableEventsProcessing); 
    718     } 
    719  
     710    for (auto couplerOut : couplerOutClient_) 
     711      if (!finalized) couplerOut.second->checkBuffers(); 
     712     
     713    for (auto couplerIn : couplerInClient_) 
     714      if (!finalized) couplerIn.second->checkBuffers(); 
     715     
     716    for (auto couplerOut : couplerOutServer_) 
     717      if (!finalized) couplerOut.second->eventLoop(enableEventsProcessing); 
     718 
     719    for (auto couplerIn : couplerInServer_) 
     720      if (!finalized) couplerIn.second->eventLoop(enableEventsProcessing); 
     721     
    720722    if (server!=nullptr) if (!finalized) finished &= server->eventLoop(enableEventsProcessing); 
    721723   
     
    723725  } 
    724726 
    725   void CContext::addCouplingChanel(const std::string& context, bool out) 
     727  void CContext::addCouplingChanel(const std::string& fullContextId, bool out) 
    726728  { 
    727      vector<string> vectStr=splitRegex(context,"::") ; 
    728      string poolId=vectStr[0] ; 
    729      string serviceId=poolId ; 
    730      string contextId=vectStr[1] ; 
    731  
    732729     int contextLeader ; 
    733      int type = CServicesManager::CLIENT ; 
    734      string contextName=CXios::getContextsManager()->getServerContextName(poolId, serviceId, 0, type, contextId) ; 
    735730      
    736      if (couplerClient_.find(contextName)==couplerClient_.end()) 
    737      { 
    738        bool ok=CXios::getContextsManager()->getContextLeader(contextName, contextLeader, getIntraComm()) ; 
     731     if (out) 
     732     {  
     733       if (couplerOutClient_.find(fullContextId)==couplerOutClient_.end())  
     734       { 
     735         bool ok=CXios::getContextsManager()->getContextLeader(fullContextId, contextLeader, getIntraComm()) ; 
    739736      
    740        MPI_Comm interComm, interCommClient, interCommServer  ; 
    741        MPI_Comm intraCommClient, intraCommServer ; 
    742  
    743        if (ok) MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ; 
    744  
    745        MPI_Comm_dup(intraComm_, &intraCommClient) ; 
    746        MPI_Comm_dup(intraComm_, &intraCommServer) ; 
    747        if (out) 
    748        { 
    749          MPI_Comm_dup(interComm, &interCommClient) ; 
    750          MPI_Comm_dup(interComm, &interCommServer) ; 
    751          CContextClient* client = new CContextClient(this, intraCommClient, interCommClient); 
    752          CContextServer* server = new CContextServer(this, intraCommServer, interCommServer); 
    753          client->setAssociatedServer(server) ; 
    754          server->setAssociatedClient(client) ; 
    755        } 
    756        else 
    757        { 
    758           MPI_Comm_dup(interComm, &interCommServer) ; 
    759           MPI_Comm_dup(interComm, &interCommClient) ; 
    760           CContextServer* server = new CContextServer(this, intraCommServer, interCommServer); 
    761           CContextClient* client = new CContextClient(this, intraCommClient, interCommClient); 
    762           client->setAssociatedServer(server) ; 
    763           server->setAssociatedClient(client) ; 
    764        } 
    765        MPI_Comm_free(&interComm) ; 
    766  
    767  
     737         MPI_Comm interComm, interCommClient, interCommServer  ; 
     738         MPI_Comm intraCommClient, intraCommServer ; 
     739 
     740         if (ok) MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ; 
     741 
     742        MPI_Comm_dup(intraComm_, &intraCommClient) ; 
     743        MPI_Comm_dup(intraComm_, &intraCommServer) ; 
     744        MPI_Comm_dup(interComm, &interCommClient) ; 
     745        MPI_Comm_dup(interComm, &interCommServer) ; 
     746        CContextClient* client = new CContextClient(this, intraCommClient, interCommClient); 
     747        CContextServer* server = new CContextServer(this, intraCommServer, interCommServer); 
     748        client->setAssociatedServer(server) ; 
     749        server->setAssociatedClient(client) ; 
     750        MPI_Comm_free(&interComm) ; 
     751        couplerOutClient_[fullContextId] = client ; 
     752        couplerOutServer_[fullContextId] = server ; 
     753 
     754/* 
    768755      // for now, we don't now which beffer size must be used for client coupler 
    769756      // It will be evaluated later. Fix a constant size for now... 
     
    777764 
    778765       client->setBufferSize(bufferSize, maxEventSize);     
    779         
    780        couplerClient_[contextName] = client ; 
    781        couplerServer_[contextName] = server ; 
    782      } 
     766*/ 
     767      } 
     768    } 
     769    else if (couplerInClient_.find(fullContextId)==couplerInClient_.end()) 
     770    { 
     771      bool ok=CXios::getContextsManager()->getContextLeader(fullContextId, contextLeader, getIntraComm()) ; 
     772      
     773       MPI_Comm interComm, interCommClient, interCommServer  ; 
     774       MPI_Comm intraCommClient, intraCommServer ; 
     775 
     776       if (ok) MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ; 
     777 
     778       MPI_Comm_dup(intraComm_, &intraCommClient) ; 
     779       MPI_Comm_dup(intraComm_, &intraCommServer) ; 
     780       MPI_Comm_dup(interComm, &interCommServer) ; 
     781       MPI_Comm_dup(interComm, &interCommClient) ; 
     782       CContextServer* server = new CContextServer(this, intraCommServer, interCommServer); 
     783       CContextClient* client = new CContextClient(this, intraCommClient, interCommClient); 
     784       client->setAssociatedServer(server) ; 
     785       server->setAssociatedClient(client) ; 
     786       MPI_Comm_free(&interComm) ; 
     787 
     788       map<int,size_t> bufferSize, maxEventSize ; 
     789       for(int i=0;i<client->getRemoteSize();i++) 
     790       { 
     791         bufferSize[i]=10000000 ; 
     792         maxEventSize[i]=10000000 ; 
     793       } 
     794 
     795       client->setBufferSize(bufferSize, maxEventSize);     
     796       couplerInClient_[fullContextId] = client ; 
     797       couplerInServer_[fullContextId] = server ;         
     798    } 
    783799  } 
    784800   
     
    798814      if (serviceType_==CServicesManager::CLIENT) 
    799815      { 
    800         doPreTimestepOperationsForEnabledReadModeFiles(); // For now we only use server level 1 to read data 
     816//ym        doPreTimestepOperationsForEnabledReadModeFiles(); // For now we only use server level 1 to read data 
     817 
     818        triggerLateFields() ; 
     819 
     820        // inform couplerIn that I am finished 
     821        for(auto& couplerInClient : couplerInClient_) sendCouplerInContextFinalized(couplerInClient.second) ; 
     822 
     823        // wait until received message from couplerOut that they have finished 
     824        bool couplersInFinalized ; 
     825        do 
     826        { 
     827          couplersInFinalized=true ; 
     828          for(auto& couplerOutClient : couplerOutClient_) couplersInFinalized &= isCouplerInContextFinalized(couplerOutClient.second) ;  
     829          globalEventLoop() ; 
     830        } while (!couplersInFinalized) ; 
    801831 
    802832        info(100)<<"DEBUG: context "<<getId()<<" Send client finalize"<<endl ; 
     
    10551085    vector<CField*>&& fileOutField = findAllEnabledFieldsInFileOut(this->enabledWriteModeFiles); 
    10561086    vector<CField*>&& fileInField = findAllEnabledFieldsInFileIn(this->enabledReadModeFiles); 
    1057     vector<CField*>&& CouplerOutField = findAllEnabledFieldsCouplerOut(this->enabledCouplerOut); 
    1058     vector<CField*>&& CouplerInField = findAllEnabledFieldsCouplerIn(this->enabledCouplerIn); 
     1087    vector<CField*>&& couplerOutField = findAllEnabledFieldsCouplerOut(this->enabledCouplerOut); 
     1088    vector<CField*>&& couplerInField = findAllEnabledFieldsCouplerIn(this->enabledCouplerIn); 
    10591089    findFieldsWithReadAccess(); 
    10601090    vector<CField*>& fieldWithReadAccess = fieldsWithReadAccess_ ; 
     
    10731103    } 
    10741104 
    1075  
    1076  
     1105     
     1106    for (auto& field : couplerInField) 
     1107    { 
     1108      field->unsetGridCompleted() ; 
     1109    } 
    10771110// find all field potentially at workflow end 
    10781111    vector<CField*> endWorkflowFields ; 
    1079     endWorkflowFields.reserve(fileOutField.size()+CouplerOutField.size()+fieldWithReadAccess.size()) ; 
     1112    endWorkflowFields.reserve(fileOutField.size()+couplerOutField.size()+fieldWithReadAccess.size()) ; 
    10801113    endWorkflowFields.insert(endWorkflowFields.end(),fileOutField.begin(), fileOutField.end()) ; 
    1081     endWorkflowFields.insert(endWorkflowFields.end(),CouplerOutField.begin(), CouplerOutField.end()) ; 
     1114    endWorkflowFields.insert(endWorkflowFields.end(),couplerOutField.begin(), couplerOutField.end()) ; 
    10821115    endWorkflowFields.insert(endWorkflowFields.end(),fieldWithReadAccess.begin(), fieldWithReadAccess.end()) ; 
    10831116 
    1084     for(auto endWorkflowField : endWorkflowFields) endWorkflowField->buildWorkflowGraph(garbageCollector) ; 
     1117    bool workflowGraphIsCompleted ; 
     1118 
     1119    bool first=true ; 
     1120    do 
     1121    { 
     1122      workflowGraphIsCompleted=true;  
     1123      for(auto endWorkflowField : endWorkflowFields)  
     1124      { 
     1125        workflowGraphIsCompleted &= endWorkflowField->buildWorkflowGraph(garbageCollector) ; 
     1126      } 
     1127 
     1128      for(auto couplerIn : enabledCouplerIn) couplerIn->assignContext() ; 
     1129      for(auto field : couplerInField) field->makeGridAliasForCoupling(); 
     1130      for(auto field : couplerInField) this->sendCouplerInReady(field->getContextClient()) ; 
    10851131     
     1132 
     1133      // assign context to coupler out and related fields 
     1134      for(auto couplerOut : enabledCouplerOut) couplerOut->assignContext() ; 
     1135      // for now supose that all coupling out endpoint are succesfull. The difficultie is client/server buffer evaluation 
     1136      for(auto field : couplerOutField)  
     1137      { 
     1138        field->computeGridIndexToFileServer() ; // same kind of index than for file server -> in future distribution may change 
     1139      } 
     1140      if (first) setClientServerBuffer(couplerOutField, true) ; // set buffer context 
     1141 
     1142      bool couplersReady ; 
     1143      do  
     1144      { 
     1145        couplersReady=true ; 
     1146        for(auto field : couplerOutField) 
     1147        { 
     1148          bool ready = isCouplerInReady(field->getContextClient()) ;  
     1149          if (ready) field->sendFieldToCouplerOut() ; 
     1150          couplersReady &= ready ; 
     1151        } 
     1152        if (!couplersReady) this->eventLoop() ; 
     1153      } while (!couplersReady) ; 
     1154 
     1155      first=false ; 
     1156      this->eventLoop() ; 
     1157    } while (!workflowGraphIsCompleted) ; 
     1158 
     1159    for( auto field : couplerInField) couplerInFields_.push_back(field) ; 
     1160 
    10861161    // get all field coming potentially from model 
    10871162    for (auto field : CField::getAll() ) if (field->getModelIn()) fieldModelIn.push_back(field) ; 
     
    11011176        field->computeGridIndexToFileServer() ; // compute grid index for transfer to the server context 
    11021177      } 
    1103       setClientServerBuffer(fileOutField, true) ; // set context 
     1178      setClientServerBuffer(fileOutField, true) ; // set buffer context 
    11041179      for(auto field : fileOutField) field->sendFieldToFileServer() ; 
    11051180    } 
     
    11461221    } 
    11471222 
     1223     
     1224    for(auto field : couplerInField)  
     1225    { 
     1226      field->connectToCouplerIn(garbageCollector) ; // connect the field to server filter 
     1227    } 
     1228     
     1229     
     1230    for(auto field : couplerOutField)  
     1231    { 
     1232      field->connectToCouplerOut(garbageCollector) ; // for now the same kind of filter that for file server 
     1233    } 
     1234 
    11481235     // workflow startpoint => data from server on client side 
    11491236    if (serviceType_==CServicesManager::CLIENT) 
     
    11511238      for(auto field : fileInField)  
    11521239      { 
    1153         field->connectToServerInput(garbageCollector) ; // connect the field to server filter 
     1240        field->connectToServerInput(garbageCollector) ; // connect tFhe field to server filter 
    11541241        field->computeGridIndexToFileServer() ; // compute grid index for transfer to the server context 
    11551242        field->sendFieldToInputFileServer() ; 
     
    11621249      // no filter for reading data from file => to be implemented 
    11631250    } 
    1164  
    1165  
    1166     if (serviceType_==CServicesManager::CLIENT || serviceType_==CServicesManager::GATHERER) this->sendCloseDefinition(); 
     1251     
     1252    // construct slave server list 
     1253    if (serviceType_==CServicesManager::CLIENT || serviceType_==CServicesManager::GATHERER)  
     1254    { 
     1255      for(auto field : fileOutField) slaveServers_.insert(field->getContextClient()) ;  
     1256      for(auto field : fileInField)  slaveServers_.insert(field->getContextClient()) ;   
     1257    } 
     1258 
     1259    for(auto& slaveServer : slaveServers_) sendCloseDefinition(slaveServer) ; 
     1260 
    11671261    if (serviceType_==CServicesManager::IO_SERVER || serviceType_==CServicesManager::OUT_SERVER)   
    11681262    { 
     
    11721266    if (serviceType_==CServicesManager::CLIENT) startPrefetchingOfEnabledReadModeFiles(); 
    11731267    
    1174  
    1175  
     1268    // send signal to couplerIn context that definition phasis is done 
     1269 
     1270    for(auto& couplerInClient : couplerInClient_) sendCouplerInCloseDefinition(couplerInClient.second) ; 
     1271 
     1272    // wait until all couplerIn signal that closeDefition is done. 
     1273    bool ok; 
     1274    do 
     1275    { 
     1276      ok = true ; 
     1277      for(auto& couplerOutClient : couplerOutClient_) ok &= isCouplerInCloseDefinition(couplerOutClient.second) ; 
     1278      this->eventLoop() ;  
     1279    } while (!ok) ; 
    11761280 
    11771281    return ; 
     1282 
     1283 
     1284 
     1285 
     1286 
     1287 
     1288 
     1289 
     1290 
     1291 
    11781292    // For now, only read files with client and only one level server 
    11791293    // if (hasClient && !hasServer) findEnabledReadModeFiles();       
     
    19872101             recvPostProcessing(event); 
    19882102             return true; 
    1989             case EVENT_ID_SEND_REGISTRY: 
     2103           case EVENT_ID_SEND_REGISTRY: 
    19902104             recvRegistry(event); 
    19912105             return true; 
    19922106             break; 
    1993             case EVENT_ID_POST_PROCESS_GLOBAL_ATTRIBUTES: 
     2107           case EVENT_ID_POST_PROCESS_GLOBAL_ATTRIBUTES: 
    19942108             recvPostProcessingGlobalAttributes(event); 
    19952109             return true; 
    19962110             break; 
    1997             case EVENT_ID_PROCESS_GRID_ENABLED_FIELDS: 
     2111           case EVENT_ID_PROCESS_GRID_ENABLED_FIELDS: 
    19982112             recvProcessingGridOfEnabledFields(event); 
    19992113             return true; 
    20002114             break; 
     2115           case EVENT_ID_COUPLER_IN_READY: 
     2116             recvCouplerInReady(event); 
     2117             return true; 
     2118             break; 
     2119           case EVENT_ID_COUPLER_IN_CLOSE_DEFINITION: 
     2120             recvCouplerInCloseDefinition(event); 
     2121             return true; 
     2122             break; 
     2123           case EVENT_ID_COUPLER_IN_CONTEXT_FINALIZED: 
     2124             recvCouplerInContextFinalized(event); 
     2125             return true; 
     2126             break;   
    20012127           default : 
    20022128             ERROR("bool CContext::dispatchEvent(CEventServer& event)", 
     
    20092135 
    20102136   //! Client side: Send a message to server to make it close 
     2137   // ym obsolete 
    20112138   void CContext::sendCloseDefinition(void) 
    20122139   TRY 
     
    20352162   } 
    20362163   CATCH_DUMP_ATTR 
     2164    
     2165   //  ! Client side: Send a message to server to make it close 
     2166   void CContext::sendCloseDefinition(CContextClient* client) 
     2167   TRY 
     2168   { 
     2169      if (sendCloseDefinition_done_.count(client)!=0) return ; 
     2170      else sendCloseDefinition_done_.insert(client) ; 
     2171 
     2172      CEventClient event(getType(),EVENT_ID_CLOSE_DEFINITION); 
     2173      if (client->isServerLeader()) 
     2174      { 
     2175        CMessage msg; 
     2176        for(auto rank : client->getRanksServerLeader()) event.push(rank,1,msg); 
     2177        client->sendEvent(event); 
     2178      } 
     2179     else client->sendEvent(event); 
     2180   } 
     2181   CATCH_DUMP_ATTR 
    20372182 
    20382183   //! Server side: Receive a message of client announcing a context close 
     
    20492194   TRY 
    20502195   { 
    2051     int nbSrvPools ; 
    2052     if (serviceType_==CServicesManager::CLIENT) nbSrvPools = 1 ; 
    2053     else if (serviceType_==CServicesManager::GATHERER) nbSrvPools = this->clientPrimServer.size() ; 
    2054     else nbSrvPools = 0 ; 
    2055     CContextClient* contextClientTmp ; 
    2056  
    2057     for (int i = 0; i < nbSrvPools; ++i) 
    2058     { 
    2059        if (serviceType_==CServicesManager::CLIENT) contextClientTmp = client ; 
    2060        else if (serviceType_==CServicesManager::GATHERER ) contextClientTmp = clientPrimServer[i] ; 
    2061        CEventClient event(getType(),EVENT_ID_UPDATE_CALENDAR); 
    2062  
    2063          if (contextClientTmp->isServerLeader()) 
    2064          { 
    2065            CMessage msg; 
    2066            msg<<step; 
    2067            const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
    2068            for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    2069              event.push(*itRank,1,msg); 
    2070            contextClientTmp->sendEvent(event); 
    2071          } 
    2072          else contextClientTmp->sendEvent(event); 
     2196     CEventClient event(getType(),EVENT_ID_UPDATE_CALENDAR); 
     2197     for(auto client : slaveServers_)  
     2198     { 
     2199       if (client->isServerLeader()) 
     2200       { 
     2201         CMessage msg; 
     2202         msg<<step; 
     2203         for (auto& rank : client->getRanksServerLeader() ) event.push(rank,1,msg); 
     2204         client->sendEvent(event); 
     2205       } 
     2206       else client->sendEvent(event); 
    20732207     } 
    20742208   } 
     
    25802714   CATCH_DUMP_ATTR 
    25812715 
     2716   void CContext::triggerLateFields(void) 
     2717   TRY 
     2718   { 
     2719    for(auto& field : fileInFields_) field->triggerLateField() ; 
     2720    for(auto& field : couplerInFields_) field->triggerLateField() ; 
     2721   } 
     2722   CATCH_DUMP_ATTR 
     2723 
    25822724   //! Update calendar in each time step 
    25832725   void CContext::updateCalendar(int step) 
     
    25902732        if (serviceType_==CServicesManager::CLIENT) // For now we only use server level 1 to read data 
    25912733        { 
    2592           doPreTimestepOperationsForEnabledReadModeFiles(); 
     2734          triggerLateFields(); 
    25932735        } 
    25942736 
     
    27712913  } 
    27722914  CATCH_DUMP_ATTR 
     2915 
     2916 
     2917 
     2918 
     2919 //! Client side: Send a message  announcing that context can receive grid definition from coupling 
     2920   void CContext::sendCouplerInReady(CContextClient* client) 
     2921   TRY 
     2922   { 
     2923      if (sendCouplerInReady_done_.count(client)!=0) return ; 
     2924      else sendCouplerInReady_done_.insert(client) ; 
     2925 
     2926      CEventClient event(getType(),EVENT_ID_COUPLER_IN_READY); 
     2927 
     2928      if (client->isServerLeader()) 
     2929      { 
     2930        CMessage msg; 
     2931        msg<<this->getId(); 
     2932        for (auto& rank : client->getRanksServerLeader()) event.push(rank,1,msg); 
     2933        client->sendEvent(event); 
     2934      } 
     2935      else client->sendEvent(event); 
     2936   } 
     2937   CATCH_DUMP_ATTR 
     2938 
     2939   //! Server side: Receive a message announcing that context can send grid definition for context coupling 
     2940   void CContext::recvCouplerInReady(CEventServer& event) 
     2941   TRY 
     2942   { 
     2943      CBufferIn* buffer=event.subEvents.begin()->buffer; 
     2944      getCurrent()->recvCouplerInReady(*buffer); 
     2945   } 
     2946   CATCH 
     2947 
     2948   //! Server side: Receive a message announcing that context can send grid definition for context coupling 
     2949   void CContext::recvCouplerInReady(CBufferIn& buffer) 
     2950   TRY 
     2951   { 
     2952      string contextId ; 
     2953      buffer>>contextId; 
     2954      couplerInReady_.insert(getCouplerOutClient(contextId)) ; 
     2955   } 
     2956   CATCH_DUMP_ATTR 
     2957 
     2958 
     2959 
     2960 
     2961 
     2962 //! Client side: Send a message  announcing that a coupling context have done it closeDefinition, so data can be sent now. 
     2963   void CContext::sendCouplerInCloseDefinition(CContextClient* client) 
     2964   TRY 
     2965   { 
     2966      if (sendCouplerInCloseDefinition_done_.count(client)!=0) return ; 
     2967      else sendCouplerInCloseDefinition_done_.insert(client) ; 
     2968 
     2969      CEventClient event(getType(),EVENT_ID_COUPLER_IN_CLOSE_DEFINITION); 
     2970 
     2971      if (client->isServerLeader()) 
     2972      { 
     2973        CMessage msg; 
     2974        msg<<this->getId(); 
     2975        for (auto& rank : client->getRanksServerLeader()) event.push(rank,1,msg); 
     2976        client->sendEvent(event); 
     2977      } 
     2978      else client->sendEvent(event); 
     2979   } 
     2980   CATCH_DUMP_ATTR 
     2981 
     2982   //! Server side: Receive a message announcing that a coupling context have done it closeDefinition, so data can be sent now. 
     2983   void CContext::recvCouplerInCloseDefinition(CEventServer& event) 
     2984   TRY 
     2985   { 
     2986      CBufferIn* buffer=event.subEvents.begin()->buffer; 
     2987      getCurrent()->recvCouplerInCloseDefinition(*buffer); 
     2988   } 
     2989   CATCH 
     2990 
     2991   //! Server side: Receive a message announcing that a coupling context have done it closeDefinition, so data can be sent now. 
     2992   void CContext::recvCouplerInCloseDefinition(CBufferIn& buffer) 
     2993   TRY 
     2994   { 
     2995      string contextId ; 
     2996      buffer>>contextId; 
     2997      couplerInCloseDefinition_.insert(getCouplerOutClient(contextId)) ; 
     2998   } 
     2999   CATCH_DUMP_ATTR 
     3000 
     3001 
     3002 
     3003 
     3004//! Client side: Send a message  announcing that a coupling context have done it contextFinalize, so it can also close it own context. 
     3005   void CContext::sendCouplerInContextFinalized(CContextClient* client) 
     3006   TRY 
     3007   { 
     3008      if (sendCouplerInContextFinalized_done_.count(client)!=0) return ; 
     3009      else sendCouplerInContextFinalized_done_.insert(client) ; 
     3010 
     3011      CEventClient event(getType(),EVENT_ID_COUPLER_IN_CONTEXT_FINALIZED); 
     3012 
     3013      if (client->isServerLeader()) 
     3014      { 
     3015        CMessage msg; 
     3016        msg<<this->getId(); 
     3017        for (auto& rank : client->getRanksServerLeader()) event.push(rank,1,msg); 
     3018        client->sendEvent(event); 
     3019      } 
     3020      else client->sendEvent(event); 
     3021   } 
     3022   CATCH_DUMP_ATTR 
     3023 
     3024   //! Server side: Receive a message announcing that a coupling context have done it contextFinalize, so it can also close it own context. 
     3025   void CContext::recvCouplerInContextFinalized(CEventServer& event) 
     3026   TRY 
     3027   { 
     3028      CBufferIn* buffer=event.subEvents.begin()->buffer; 
     3029      getCurrent()->recvCouplerInContextFinalized(*buffer); 
     3030   } 
     3031   CATCH 
     3032 
     3033   //! Server side: Receive a message announcing that a coupling context have done it contextFinalize, so it can also close it own context. 
     3034   void CContext::recvCouplerInContextFinalized(CBufferIn& buffer) 
     3035   TRY 
     3036   { 
     3037      string contextId ; 
     3038      buffer>>contextId; 
     3039      couplerInContextFinalized_.insert(getCouplerOutClient(contextId)) ; 
     3040   } 
     3041   CATCH_DUMP_ATTR 
    27733042 
    27743043 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/context.hpp

    r1870 r1875  
    5757           EVENT_ID_PROCESS_GRID_ENABLED_FIELDS, 
    5858           EVENT_ID_CONTEXT_FINALIZE_CLIENT, 
     59           EVENT_ID_COUPLER_IN_READY, 
     60           EVENT_ID_COUPLER_IN_CLOSE_DEFINITION, 
     61           EVENT_ID_COUPLER_IN_CONTEXT_FINALIZED, 
    5962         }; 
    6063 
     
    150153         void postProcessing(); 
    151154         void postProcessingGlobalAttributes();          
    152  
     155         void triggerLateFields(void) ; 
    153156         void solveAllRefOfEnabledFieldsAndTransform(void); 
    154157         void checkGridEnabledFields(); 
     
    169172         // Send context close definition 
    170173         void sendCloseDefinition(void); 
     174       public: 
     175         void sendCloseDefinition(CContextClient* client) ; 
     176       private: 
     177         set<CContextClient*> sendCloseDefinition_done_ ; 
     178       public: 
    171179         // There are something to send on closing context defintion 
    172180         void sendUpdateCalendar(int step); 
     
    208216         static void recvFinalizeClient(CEventServer& event) ; 
    209217         void recvFinalizeClient(CBufferIn& buffer); 
    210           
    211          void freeComms(void);                  //!< Free internally allcoated communicators 
    212          void releaseClientBuffers(void);       //! Deallocate buffers allocated by clientContexts 
     218         
     219       public: 
     220         void sendCouplerInReady(CContextClient* client); 
     221       private: 
     222         set<CContextClient*> sendCouplerInReady_done_; 
     223       public: 
     224         static void recvCouplerInReady(CEventServer& event) ; 
     225         void recvCouplerInReady(CBufferIn& buffer) ; //!< coupler is ready to receive grid definition. 
     226         set<CContextClient*> couplerInReady_; 
     227         bool isCouplerInReady(CContextClient* client) { return couplerInReady_.count(client)!=0 ;} 
     228 
     229       public: 
     230        void sendCouplerInCloseDefinition(CContextClient* client) ; 
     231        set<CContextClient*> sendCouplerInCloseDefinition_done_; 
     232        static void recvCouplerInCloseDefinition(CEventServer& event) ; 
     233        void recvCouplerInCloseDefinition(CBufferIn& buffer) ; //!< coupler has finished it defintion, data can be sent      
     234        set<CContextClient*> couplerInCloseDefinition_ ; 
     235        bool isCouplerInCloseDefinition(CContextClient* client) { return couplerInCloseDefinition_.count(client)!=0 ;} 
     236 
     237       public: 
     238        void sendCouplerInContextFinalized(CContextClient* client) ; 
     239        set<CContextClient*> sendCouplerInContextFinalized_done_; 
     240        static void recvCouplerInContextFinalized(CEventServer& event) ; 
     241        void recvCouplerInContextFinalized(CBufferIn& buffer) ; //!< coupler has finished it defintion, data can be sent      
     242        set<CContextClient*> couplerInContextFinalized_ ; 
     243        bool isCouplerInContextFinalized(CContextClient* client) { return couplerInContextFinalized_.count(client)!=0 ;} 
     244 
     245       public:   
     246        void freeComms(void);                  //!< Free internally allcoated communicators 
     247        void releaseClientBuffers(void);       //! Deallocate buffers allocated by clientContexts 
    213248 
    214249         // dispatch event 
     
    281316         // but which are not part of a file 
    282317         std::vector<CField*> fieldsWithReadAccess_; 
     318         std::vector<CField*> couplerInFields_; 
     319         std::vector<CField*> fileInFields_; 
     320 
    283321 
    284322         // Context root 
     
    295333         std::vector<CContextServer*> serverPrimServer; 
    296334         std::vector<CContextClient*> clientPrimServer; 
    297          std::map<std::string, CContextClient*> couplerClient_ ; 
    298          std::map<std::string, CContextServer*> couplerServer_ ; 
    299  
    300  
     335 
     336         // list of slave servers (IO server or others) 
     337         set<CContextClient*> slaveServers_ ; 
     338      private: 
     339         // the map containing context client associated to it string id for coupling out ; 
     340         std::map<std::string, CContextClient*> couplerOutClient_ ; 
     341         // the map containing context server associated to it string id for coupling out ; 
     342         std::map<std::string, CContextServer*> couplerOutServer_ ; 
     343         // the map containing context client associated to it string id for coupling in ; 
     344         std::map<std::string, CContextClient*> couplerInClient_ ; 
     345         // the map containing context server associated to it string id for coupling in ; 
     346         std::map<std::string, CContextServer*> couplerInServer_ ; 
     347      public: 
     348         CContextClient* getCouplerInClient(const string& contextId) { return couplerInClient_[contextId] ;} 
     349         CContextServer* getCouplerInServer(const string& contextId) { return couplerInServer_[contextId] ;} 
     350         CContextClient* getCouplerOutClient(const string& contextId) { return couplerOutClient_[contextId] ;} 
     351         CContextServer* getCouplerOutServer(const string& contextId) { return couplerOutServer_[contextId] ;} 
     352       
     353   
    301354         std::vector<std::string> primServerId_; 
    302355 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/coupler_in.cpp

    r1784 r1875  
    5151   CATCH_DUMP_ATTR 
    5252 
     53   const string& CCouplerIn::getCouplingContextId(void) 
     54   { 
     55     if (couplingContextId_.empty()) 
     56     { 
     57       vector<string> vectStr=splitRegex(context,"::") ; 
     58       string poolId=vectStr[0] ; 
     59       string serviceId=poolId ; 
     60       string contextId=vectStr[1] ; 
     61       int contextLeader ; 
     62       int type = CServicesManager::CLIENT ; 
     63       couplingContextId_=CXios::getContextsManager()->getServerContextName(poolId, serviceId, 0, type, contextId) ; 
     64     } 
     65     return couplingContextId_ ; 
     66   } 
     67 
    5368   void CCouplerIn::createInterCommunicator(void) 
    5469   TRY 
     
    6075     } 
    6176     CContext* contextPtr = CContext::getCurrent(); 
    62      contextPtr->addCouplingChanel(context, false) ; 
     77     contextPtr->addCouplingChanel(getCouplingContextId(), false) ; 
    6378   } 
    6479   CATCH_DUMP_ATTR 
     
    132147   CATCH 
    133148 
    134  
     149  /*! 
     150   * assign the context associated to the coupler to the enabled fields 
     151   */ 
     152   void  CCouplerIn::assignContext(void) 
     153   { 
     154     client_ = CContext::getCurrent()->getCouplerInClient(getCouplingContextId()); 
     155     for (auto& field : getEnabledFields()) field->setContextClient(client_) ;  
     156   } 
    135157 
    136158   //---------------------------------------------------------------- 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/coupler_in.hpp

    r1784 r1875  
    9696         void solveFieldRefInheritance(bool apply); 
    9797         void createInterCommunicator(void) ; 
     98         void assignContext(void) ; 
     99       
     100      private: 
     101        CContextClient* client_=nullptr ; 
     102      public: 
     103         CContextClient* getContextClient(void) {return client_; } 
     104       
     105      private: 
     106        string couplingContextId_ ; 
     107      public: 
     108        const string& getCouplingContextId(void) ;   
    98109 
    99110      private : 
     111 
    100112         CFieldGroup* virtualFieldGroup; 
    101113 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/coupler_out.cpp

    r1784 r1875  
    5454   } 
    5555   CATCH_DUMP_ATTR 
     56 
     57   const string& CCouplerOut::getCouplingContextId(void) 
     58   { 
     59     if (couplingContextId_.empty()) 
     60     { 
     61       vector<string> vectStr=splitRegex(context,"::") ; 
     62       string poolId=vectStr[0] ; 
     63       string serviceId=poolId ; 
     64       string contextId=vectStr[1] ; 
     65       int contextLeader ; 
     66       int type = CServicesManager::CLIENT ; 
     67       couplingContextId_=CXios::getContextsManager()->getServerContextName(poolId, serviceId, 0, type, contextId) ; 
     68     } 
     69     return couplingContextId_ ; 
     70   } 
    5671 
    5772   std::vector<CField*> CCouplerOut::getEnabledFields(void) 
     
    7590   CATCH_DUMP_ATTR 
    7691 
     92   /*! 
     93    * assign the context associated to the coupler to the enabled fields 
     94    */ 
     95   void  CCouplerOut::assignContext(void) 
     96   { 
     97     client_ = CContext::getCurrent()->getCouplerOutClient(getCouplingContextId()); 
     98     for (auto& field : getEnabledFields()) field->setContextClient(client_) ;  
     99   } 
     100 
    77101      /*! 
    78102   \brief Get virtual field group 
     
    133157     } 
    134158     CContext* contextPtr = CContext::getCurrent(); 
    135      contextPtr->addCouplingChanel(context, true) ; 
     159     contextPtr->addCouplingChanel(getCouplingContextId(), true) ; 
    136160   } 
    137161   CATCH_DUMP_ATTR 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/coupler_out.hpp

    r1784 r1875  
    9696        void buildFilterGraphOfEnabledFields(CGarbageCollector& gc); 
    9797        void checkGridOfEnabledFields(void) ; 
    98  
    99       private : 
     98        void assignContext(void) ; 
     99      private: 
     100        // the contextClient associated to the context Id attribute 
     101        CContextClient* client_=nullptr ; 
     102      public:  
     103        CContextClient* getContextClient(void) {return client_; } 
     104       
     105      private: 
     106        string couplingContextId_ ; 
     107      public: 
     108        const string& getCouplingContextId(void) ;   
     109      private: 
    100110         CFieldGroup* virtualFieldGroup; 
    101111 
     
    118128} // namespace xios 
    119129 
    120 #endif // __XIOS_CCouplingIn__ 
     130#endif // __XIOS_CCouplingIn__2 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/domain.cpp

    r1871 r1875  
    21012101  } 
    21022102 
     2103  void CDomain::sendDomainToCouplerOut(CContextClient* client, const string& fieldId, int posInGrid) 
     2104  { 
     2105    if (sendDomainToFileServer_done_.count(client)!=0) return ; 
     2106    else sendDomainToFileServer_done_.insert(client) ; 
     2107     
     2108    const string domainId = "_domain["+std::to_string(posInGrid)+"]_of_"+fieldId ; 
     2109     
     2110    if (!domain_ref.isEmpty()) 
     2111    { 
     2112      auto domain_ref_tmp=domain_ref.getValue() ; 
     2113      domain_ref.reset() ; // remove the reference, find an other way to do that more cleanly 
     2114      this->sendAllAttributesToServer(client, domainId)  ; 
     2115      domain_ref = domain_ref_tmp ; 
     2116    } 
     2117    else this->sendAllAttributesToServer(client, domainId)  ; 
     2118 
     2119    this->sendDistributionAttributes(client, domainId);    
     2120    this->sendIndex(client, domainId);        
     2121    this->sendLonLat(client, domainId); 
     2122    this->sendArea(client, domainId);     
     2123    this->sendDataIndex(client, domainId); 
     2124  } 
     2125 
     2126  void CDomain::makeAliasForCoupling(const string& fieldId, int posInGrid) 
     2127  { 
     2128    const string domainId = "_domain["+std::to_string(posInGrid)+"]_of_"+fieldId ; 
     2129    this->createAlias(domainId) ; 
     2130  } 
     2131 
    21032132  /*! 
    21042133    Send all attributes from client to connected clients 
     
    21192148    Send global index from client to connected client(s) 
    21202149  */ 
    2121   void CDomain::sendIndex(CContextClient* client) 
     2150  void CDomain::sendIndex(CContextClient* client, const string& domainId) 
    21222151  TRY 
    21232152  { 
     2153    string serverDomainId = domainId.empty() ? this->getId() : domainId ; 
     2154     
    21242155    int ns, n, i, j, ind, nv, idx; 
    2125     
    21262156    int serverSize = client->serverSize; 
    21272157    CEventClient eventIndex(getType(), EVENT_ID_INDEX); 
     
    21462176 
    21472177      list_msgsIndex.push_back(CMessage()); 
    2148       list_msgsIndex.back() << this->getId() << (int)type; // enum ne fonctionne pour les message => ToFix 
     2178      list_msgsIndex.back() << serverDomainId << (int)type; // enum ne fonctionne pour les message => ToFix 
    21492179      list_msgsIndex.back() << isCurvilinear; 
    21502180      list_msgsIndex.back() << list_indGlob.back(); //list_indi.back() << list_indj.back(); 
     
    21612191    it calculates this distribution then sends it to the corresponding clients on the next level 
    21622192  */ 
    2163   void CDomain::sendDistributionAttributes(CContextClient* client) 
     2193  void CDomain::sendDistributionAttributes(CContextClient* client, const string& domainId) 
    21642194  TRY 
    21652195  { 
     2196    string serverDomainId = domainId.empty() ? this->getId() : domainId ; 
     2197 
    21662198    int nbServer = client->serverSize; 
    21672199    std::vector<int> nGlobDomain(2); 
     
    21922224        msgs.push_back(CMessage()); 
    21932225        CMessage& msg = msgs.back(); 
    2194         msg << this->getId() ; 
     2226        msg << serverDomainId ; 
    21952227        msg << isUnstructed_; 
    21962228        msg << ni_srv << ibegin_srv << nj_srv << jbegin_srv; 
     
    22092241    Send area from client to connected client(s) 
    22102242  */ 
    2211   void CDomain::sendArea(CContextClient* client) 
     2243  void CDomain::sendArea(CContextClient* client, const string& domainId) 
    22122244  TRY 
    22132245  { 
    22142246    if (!hasArea) return; 
    2215  
     2247    string serverDomainId = domainId.empty() ? this->getId() : domainId ; 
     2248     
    22162249    int ns, n, i, j, ind, nv, idx; 
    22172250    int serverSize = client->serverSize; 
     
    22422275 
    22432276      list_msgsArea.push_back(CMessage()); 
    2244       list_msgsArea.back() << this->getId() << hasArea; 
     2277      list_msgsArea.back() <<serverDomainId << hasArea; 
    22452278      list_msgsArea.back() << list_area.back(); 
    22462279      eventArea.push(rank, nbSenders[serverSize][rank], list_msgsArea.back()); 
     
    22552288    Because longitude and latitude are optional, this function only called if latitude and longitude exist 
    22562289  */ 
    2257   void CDomain::sendLonLat(CContextClient* client) 
     2290  void CDomain::sendLonLat(CContextClient* client, const string& domainId) 
    22582291  TRY 
    22592292  { 
    22602293    if (!hasLonLat) return; 
    2261  
     2294    string serverDomainId = domainId.empty() ? this->getId() : domainId ; 
     2295     
    22622296    int ns, n, i, j, ind, nv, idx; 
    22632297    int serverSize = client->serverSize; 
     
    23162350      list_msgsLat.push_back(CMessage()); 
    23172351 
    2318       list_msgsLon.back() << this->getId() << hasLonLat; 
     2352      list_msgsLon.back() << serverDomainId << hasLonLat; 
    23192353      if (hasLonLat)  
    23202354        list_msgsLon.back() << list_lon.back(); 
     
    23252359      } 
    23262360 
    2327       list_msgsLat.back() << this->getId() << hasLonLat; 
     2361      list_msgsLat.back() << serverDomainId << hasLonLat; 
    23282362      if (hasLonLat) 
    23292363        list_msgsLat.back() << list_lat.back(); 
     
    23482382    The compressed index are represented with 1 and others are represented with -1 
    23492383  */ 
    2350   void CDomain::sendDataIndex(CContextClient* client) 
     2384  void CDomain::sendDataIndex(CContextClient* client, const string& domainId) 
    23512385  TRY 
    23522386  { 
     2387    string serverDomainId = domainId.empty() ? this->getId() : domainId ; 
     2388     
    23532389    int ns, n, i, j, ind, nv, idx; 
    23542390    int serverSize = client->serverSize; 
     
    24062442 
    24072443      list_msgsDataIndex.push_back(CMessage()); 
    2408       list_msgsDataIndex.back() << this->getId(); 
     2444      list_msgsDataIndex.back() << serverDomainId ; 
    24092445      list_msgsDataIndex.back() << list_data_i_index.back() << list_data_j_index.back(); 
    24102446      eventDataIndex.push(rank, nbSenders[serverSize][rank], list_msgsDataIndex.back()); 
     
    26142650           << "The number of sending clients is not correct." 
    26152651           << "Expected number: " << recvClientRanks_.size() << " but received " << nbReceived); 
    2616  
     2652     
     2653    int nbLonInd = 0; 
    26172654    vector<CArray<double,1> > recvLonValue(nbReceived); 
    26182655    vector<CArray<double,2> > recvBoundsLonValue(nbReceived);     
     
    26312668    if (hasLonLat) 
    26322669    { 
    2633       int nbLonInd = 0; 
    26342670      for (i = 0; i < nbReceived; ++i) 
    26352671      { 
     
    26652701        } 
    26662702      }        
     2703    } 
     2704 
     2705   // setup attribute depending the type of domain 
     2706    if (hasLonLat) 
     2707    { 
     2708      nbLonInd = globalLocalIndexMap_.size(); 
     2709      if (ni*nj != nbLonInd) 
     2710        ERROR("void CDomain::recvLon(std::map<int, CBufferIn*>& rankBuffers)", 
     2711             << "The number of index received is not coherent with the given resolution" 
     2712             << "nbLonInd=" << nbLonInd << ", ni=" << ni <<", nj"<<ni<<" ni*nj="<<ni*nj); 
     2713 
     2714      if (type == type_attr::rectilinear || type == type_attr::curvilinear) 
     2715      { 
     2716        lonvalue_2d.resize(ni,nj); 
     2717          for(int ij=0, j=0 ; j<nj ; j++) 
     2718            for(int i=0 ; i<ni; i++, ij++) lonvalue_2d(i,j) = lonvalue(ij) ; 
     2719         
     2720        if (hasBounds) 
     2721        { 
     2722          bounds_lon_2d.resize(nvertex, ni, nj) ; 
     2723          for(int ij=0, j=0 ; j<nj ; j++) 
     2724            for(int i=0 ; i<ni; i++, ij++)  
     2725              for(int nv=0; nv<nvertex; nv++) bounds_lon_2d(nv,i,j) = bounds_lonvalue(nv,ij) ; 
     2726        } 
     2727      } 
     2728    } 
     2729    else if (type == type_attr::unstructured || type == type_attr::gaussian) 
     2730    { 
     2731      lonvalue_1d.resize(nbLonInd); 
     2732      lonvalue_1d = lonvalue ; 
     2733      if (hasBounds) 
     2734      { 
     2735        bounds_lon_1d.resize(nvertex, nbLonInd) ; 
     2736        bounds_lon_1d = bounds_lonvalue ; 
     2737      } 
    26672738    } 
    26682739  } 
     
    27172788    } 
    27182789 
     2790    int nbLatInd = 0; 
    27192791    if (hasLonLat) 
    27202792    { 
    2721       int nbLatInd = 0; 
    27222793      for (i = 0; i < nbReceived; ++i) 
    27232794      { 
     
    27562827      }        
    27572828    } 
     2829      // setup attribute depending the type of domain 
     2830    if (hasLonLat) 
     2831    { 
     2832      nbLatInd = globalLocalIndexMap_.size(); 
     2833       
     2834      if (ni*nj != nbLatInd) 
     2835        ERROR("void CDomain::recvLat(std::map<int, CBufferIn*>& rankBuffers)", 
     2836             << "The number of index received is not coherent with the given resolution" 
     2837            << "nbLonInd=" << nbLatInd << ", ni=" << ni <<", nj"<<ni<<" ni*nj="<<ni*nj); 
     2838 
     2839      if (type == type_attr::rectilinear || type == type_attr::curvilinear) 
     2840      { 
     2841        { 
     2842          latvalue_2d.resize(ni,nj); 
     2843          for(int ij=0, j=0 ; j<nj ; j++) 
     2844            for(int i=0 ; i<ni; i++, ij++) latvalue_2d(i,j) = latvalue(ij) ; 
     2845         
     2846          if (hasBounds) 
     2847          { 
     2848            bounds_lat_2d.resize(nvertex, ni, nj) ; 
     2849            for(int ij=0, j=0 ; j<nj ; j++) 
     2850              for(int i=0 ; i<ni; i++, ij++)  
     2851                for(int nv=0; nv<nvertex; nv++) bounds_lat_2d(nv,i,j) = bounds_latvalue(nv,ij) ; 
     2852          } 
     2853        } 
     2854      } 
     2855      else if (type == type_attr::unstructured || type == type_attr::gaussian) 
     2856      { 
     2857        if (hasLonLat) 
     2858        { 
     2859          latvalue_1d.resize(nbLatInd); 
     2860          latvalue_1d = latvalue ; 
     2861          if (hasBounds) 
     2862          { 
     2863            bounds_lat_1d.resize(nvertex, nbLatInd) ; 
     2864            bounds_lon_1d = bounds_lonvalue ; 
     2865          } 
     2866        } 
     2867      } 
     2868    }  
    27582869  } 
    27592870  CATCH_DUMP_ATTR 
     
    30163127  } 
    30173128  CATCH_DUMP_ATTR 
    3018  
    3019   /*! 
    3020   \brief Check if a domain is completed 
    3021   Before make any domain processing, we must be sure that all domain informations have 
    3022   been sent, for exemple when reading a grid in a file or when grid elements are sent by an 
    3023   other context (coupling). So all direct reference of the domain (domain_ref) must be also completed 
    3024   \return true if domain and domain reference are completed 
    3025   */ 
    3026   bool CDomain::checkIfCompleted(void) 
    3027   { 
    3028     if (hasDirectDomainReference()) if (!getDirectDomainReference()->checkIfCompleted()) return false; 
    3029     return isCompleted_ ; 
    3030   } 
    3031  
    3032   /*! 
    3033   \brief Set a domain as completed 
    3034    When all information about a domain have been received, the domain is tagged as completed and is 
    3035    suitable for processing 
    3036   */ 
    3037   void CDomain::setCompleted(void) 
    3038   { 
    3039     if (hasDirectDomainReference()) getDirectDomainReference()->setCompleted() ; 
    3040     isCompleted_=true ; 
    3041   } 
    3042  
    3043   /*! 
    3044   \brief Set a domain as uncompleted 
    3045    When informations about a domain are expected from a grid reading from file or coupling, the domain is  
    3046    tagged as uncompleted and is not suitable for processing 
    3047   */ 
    3048   void CDomain::setUncompleted(void) 
    3049   { 
    3050     if (hasDirectDomainReference()) getDirectDomainReference()->setUncompleted() ; 
    3051     isCompleted_=false ; 
    3052   } 
    3053    
     3129     
    30543130  /*! 
    30553131   * Go through the hierarchy to find the domain from which the transformations must be inherited 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/domain.hpp

    r1870 r1875  
    111111 
    112112         static bool dispatchEvent(CEventServer& event); 
    113  
    114          bool checkIfCompleted(void) ; 
    115          void setCompleted(void) ; 
    116          void setUncompleted(void) ; 
     113       
     114      private: 
     115         /** define if the domain is completed or not ie all attributes have been received before in case  
     116             of grid reading from file or coupling */  
     117         bool isCompleted_=true ;   
     118      public:      
     119        /*! 
     120           \brief Check if a domain is completed 
     121           Before make any domain processing, we must be sure that all domain informations have 
     122           been sent, for exemple when reading a grid in a file or when grid elements are sent by an 
     123           other context (coupling). So all direct reference of the domain (domain_ref) must be also completed 
     124           \return true if domain and domain reference are completed 
     125          */ 
     126         bool isCompleted(void) 
     127         { 
     128           if (hasDirectDomainReference()) if (!getDirectDomainReference()->isCompleted()) return false; 
     129           else return isCompleted_ ; 
     130         } 
     131         void setCompleted(void) { isCompleted_=true ; } 
     132         void unsetCompleted(void) { isCompleted_=false ; } 
    117133 
    118134      public: 
     
    190206         std::set<CContextClient*> sendDomainToFileServer_done_ ; 
    191207       private: 
    192           
     208         public: 
     209         void sendDomainToCouplerOut(CContextClient* client, const string& fieldId, int posInGrid) ; 
     210       private: 
     211         std::set<CContextClient*> sendDomainToCouplerOut_done_ ; 
     212       
     213       public: 
     214        void makeAliasForCoupling(const string& fieldId, int posInGrid) ; 
     215 
     216       private: 
     217 
    193218         void sendAttributes(); // ym obsolete -> to be removed 
    194          void sendIndex(CContextClient* client); 
    195          void sendDistributionAttributes(CContextClient* client); 
    196          void sendArea(CContextClient* client); 
    197          void sendLonLat(CContextClient* client);          
    198          void sendDataIndex(CContextClient* client); 
     219         void sendIndex(CContextClient* client, const string& domainId=""); 
     220         void sendDistributionAttributes(CContextClient* client, const string& domainId=""); 
     221         void sendArea(CContextClient* client, const string& domainId=""); 
     222         void sendLonLat(CContextClient* client, const string& domainId="");          
     223         void sendDataIndex(CContextClient* client, const string& domainId=""); 
    199224         void convertLonLatValue(); 
    200225         void fillInRectilinearLonLat(); 
     
    228253         bool isClientChecked; // Verify whether all attributes of domain on the client side are good 
    229254         bool isClientAfterTransformationChecked; 
    230           
    231          /** define if the domain is completed or not ie all attributes have been received before in case  
    232              of grid reading from file or coupling */  
    233          bool isCompleted_=true ;   
    234255 
    235256/** global index of the domain on server side, sent by the clients. This is global index for lon, lat, mask elements (ie non masked elements) 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/field.cpp

    r1872 r1875  
    133133          return true; 
    134134          break; 
    135  
     135      
     136        case EVENT_ID_GRID_COMPLETED : 
     137          recvGridCompleted(event); 
     138          return true; 
     139          break; 
    136140        default : 
    137141          ERROR("bool CField::dispatchEvent(CEventServer& event)", << "Unknown Event"); 
     
    142146  CATCH 
    143147 
    144   void CField::sendUpdateData(const CArray<double,1>& data, CContextClient* client) 
     148  void CField::sendUpdateData(Time timeStamp, const CArray<double,1>& data, CContextClient* client) 
    145149  TRY 
    146150  { 
     
    169173            for (int n = 0; n < data_tmp.numElements(); n++) data_tmp(n) = data(index(n)); 
    170174 
    171             list_msg.back() << getId() << data_tmp; 
     175            list_msg.back() << getId() << timeStamp << data_tmp; 
    172176            event.push(rank, 1, list_msg.back()); 
    173177          } 
     
    189193        for (int n = 0; n < data_tmp.numElements(); n++) data_tmp(n) = data(index(n)); 
    190194 
    191         list_msg.back() << getId() << data_tmp; 
     195        list_msg.back() << getId() << timeStamp << data_tmp; 
    192196        event.push(rank, grid_->nbSenders_[receiverSize][rank], list_msg.back()); 
    193197      } 
     
    219223  CATCH 
    220224 
     225 
    221226  void  CField::recvUpdateData(std::map<int,CBufferIn*>& rankBuffers) 
    222227  TRY 
    223228  { 
     229    if (hasCouplerIn()) recvUpdateDataFromCoupler(rankBuffers) ; 
     230    else recvUpdateDataFromClient(rankBuffers) ; 
     231  } 
     232  CATCH 
     233 
     234  void  CField::recvUpdateDataFromClient(std::map<int,CBufferIn*>& rankBuffers) 
     235  TRY 
     236  { 
    224237    CContext* context = CContext::getCurrent(); 
    225  
     238    Time timeStamp ; 
    226239    size_t sizeData = 0; 
    227240    if (0 == recvDataSrv.numElements()) 
     
    249262        CArray<double,1> tmp; 
    250263        CArray<size_t,1>& indexTmp = it->second; 
    251         *(rankBuffers[it->first]) >> tmp; 
     264        *(rankBuffers[it->first]) >> timeStamp >> tmp; 
    252265        for (int idx = 0; idx < indexTmp.numElements(); ++idx) recv_data_tmp(indexTmp(idx)) = tmp(idx); 
    253266      } 
     
    552565  CATCH 
    553566 
     567   
     568  void CField::recvUpdateDataFromCoupler(std::map<int,CBufferIn*>& rankBuffers) 
     569  TRY 
     570  { 
     571    CContext* context = CContext::getCurrent(); 
     572    Time timeStamp ; 
     573    if (wasDataAlreadyReceivedFromServer) 
     574    {   
     575      lastDataReceivedFromServer = lastDataReceivedFromServer + freq_op; 
     576    } 
     577    else 
     578    { 
     579      // unlikely to input from file server where data are received at ts=0 
     580      // for coupling, it would be after the first freq_op, because for now we don't have 
     581      // restart mecanism to send the value at ts=0. It mus be changed in future 
     582      lastDataReceivedFromServer = context->getCalendar()->getInitDate()+freq_op; 
     583      wasDataAlreadyReceivedFromServer = true; 
     584    } 
     585 
     586    CArray<int,1>& storeClient = grid_->getStoreIndex_client(); 
     587    CArray<double,1> recv_data_tmp(storeClient.numElements());   
     588 
     589    auto& outLocalIndexStoreOnClient = grid_-> getOutLocalIndexStoreOnClient() ; 
     590    for (auto it = outLocalIndexStoreOnClient.begin(); it != outLocalIndexStoreOnClient.end(); ++it) 
     591    { 
     592      CArray<double,1> tmp; 
     593      CArray<size_t,1>& indexTmp = it->second; 
     594      *(rankBuffers[it->first]) >> timeStamp >> tmp; 
     595      for (int idx = 0; idx < indexTmp.numElements(); ++idx) recv_data_tmp(indexTmp(idx)) = tmp(idx); 
     596    } 
     597     
     598    clientSourceFilter->streamData(lastDataReceivedFromServer, recv_data_tmp); 
     599     
     600  } 
     601  CATCH_DUMP_ATTR 
    554602  /*! 
    555603    Receive read data from server 
     
    596644  } 
    597645  CATCH_DUMP_ATTR 
     646 
     647  void CField::checkForLateDataFromCoupler(void) 
     648  TRY 
     649  { 
     650    CContext* context = CContext::getCurrent(); 
     651    const CDate& currentDate = context->getCalendar()->getCurrentDate(); 
     652 
     653    CTimer timer("CField::checkForLateDataFromCoupler"); 
     654    timer.resume(); 
     655    traceOff() ; 
     656    timer.suspend(); 
     657       
     658    bool isDataLate; 
     659    do 
     660    { 
     661      const CDate nextDataDue = wasDataAlreadyReceivedFromServer ? (lastDataReceivedFromServer + freq_op) : context->getCalendar()->getInitDate(); 
     662      isDataLate = (nextDataDue <= currentDate); 
     663 
     664      if (isDataLate) 
     665      { 
     666        timer.resume(); 
     667//ym          context->checkBuffersAndListen(); 
     668//ym            context->eventLoop(); 
     669        context->globalEventLoop(); 
     670 
     671        timer.suspend(); 
     672      } 
     673    } while (isDataLate && timer.getCumulatedTime() < CXios::recvFieldTimeout); 
     674     
     675    timer.resume(); 
     676    traceOn() ; 
     677    timer.suspend() ; 
     678 
     679    if (isDataLate) ERROR("void CField::checkForLateDataFromCoupler(void)", 
     680                            << "Late data at timestep = " << currentDate); 
     681  } 
     682  CATCH_DUMP_ATTR 
     683 
    598684 
    599685  void CField::checkForLateDataFromServer(void) 
     
    640726  } 
    641727  CATCH_DUMP_ATTR 
     728 
     729  void CField::triggerLateField(void) 
     730  TRY 
     731  { 
     732    if (hasFileIn())  
     733    { 
     734      checkForLateDataFromServer() ; 
     735      serverSourceFilter->trigger(CContext::getCurrent()->getCalendar()->getCurrentDate()) ; 
     736    }  
     737    else if (hasCouplerIn()) 
     738    { 
     739      checkForLateDataFromCoupler() ; 
     740      clientSourceFilter->trigger(CContext::getCurrent()->getCalendar()->getCurrentDate()) ; 
     741    } 
     742  } 
     743  CATCH_DUMP_ATTR 
     744 
    642745 
    643746  void CField::checkIfMustAutoTrigger(void) 
     
    11401243  { 
    11411244    if (buildWorkflowGraphDone_) return true ; 
     1245     
    11421246    const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
    11431247    const double defaultValue  = detectMissingValues ? default_value : (!default_value.isEmpty() ? default_value : 0.0); 
     
    11521256    } 
    11531257 
     1258    // now construct grid and check if element are enabled 
     1259    solveGridReference() ; // grid_ is now defined 
     1260    if (!isGridCompleted()) return false; 
     1261 
    11541262    // Check if we have an expression to parse 
    11551263    std::shared_ptr<COutputPin> filterExpr ; 
     
    11611269    } 
    11621270     
    1163     // now construct grid and check if element are enabled 
    1164     solveGridReference() ; // grid_ is now defined 
    1165      
    11661271    // prepare transformation. Need to know before if workflow of auxillary field can be built 
    11671272    if (hasDirectFieldReference()) 
     
    11731278      for(auto grid : gridPath) 
    11741279      { 
    1175         if (!grid->checkIfCompleted()) return false ; 
    11761280        grid->solveElementsRefInheritance() ; 
    1177         grid_->completeGrid(gridSrc); // grid generation, to be checked 
     1281        grid->completeGrid(gridSrc); // grid generation, to be checked 
     1282        grid->checkElementsAttributes() ; 
    11781283        grid->prepareTransformGrid(gridSrc) ; // prepare the grid tranformation 
    11791284        for(auto fieldId : grid->getAuxInputTransformGrid()) // try to build workflow graph for auxillary field tranformation 
     
    12051310    else  
    12061311    { 
    1207       if (!grid_->checkIfCompleted()) return false ; 
    1208        
    12091312      if (hasFileIn()) // input file, attemp to read the grid from file 
    12101313      { 
     
    12211324         instantDataFilter=inputFilter ; 
    12221325      }   
    1223       else  
     1326      else if (hasCouplerIn()) 
     1327      { 
     1328        grid_->checkElementsAttributes() ; 
     1329        instantDataFilter=inputFilter ; 
     1330      } 
     1331      else 
    12241332      { 
    12251333        setModelIn() ; // no reference, the field is potentially a source field from model 
     
    12561364    // insert temporal filter before sending to files 
    12571365    getTemporalDataFilter(gc, fileOut_->output_freq)->connectOutput(fileWriterFilter, 0); 
     1366  }  
     1367 
     1368  void CField::connectToCouplerOut(CGarbageCollector& gc) 
     1369  { 
     1370    // insert temporal filter before sending to files 
     1371    fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this, client)); 
     1372    instantDataFilter->connectOutput(fileWriterFilter, 0); 
    12581373  }  
    12591374 
     
    13031418    serverSourceFilter -> connectOutput(inputFilter,0) ; 
    13041419  }  
     1420 
     1421  /*! 
     1422   * Connect field to a source filter to receive data from coupler (on client side). 
     1423   */ 
     1424   void CField::connectToCouplerIn(CGarbageCollector& gc) 
     1425  { 
     1426    CContext* context = CContext::getCurrent(); 
     1427 
     1428    if (freq_op.isEmpty()) freq_op.setValue(TimeStep); 
     1429    if (freq_offset.isEmpty()) freq_offset.setValue(freq_op.getValue() - TimeStep); 
     1430 
     1431    freq_operation_srv = freq_op ; 
     1432    last_operation_srv = context->getCalendar()->getInitDate(); 
     1433    const CDuration toffset = freq_operation_srv - freq_offset.getValue() - context->getCalendar()->getTimeStep(); 
     1434    last_operation_srv     = last_operation_srv - toffset; 
     1435 
     1436    clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid_, false, false, freq_offset, true)) ; 
     1437    clientSourceFilter -> connectOutput(inputFilter,0) ; 
     1438  }  
     1439 
    13051440 
    13061441  /*! 
     
    20212156  CATCH_DUMP_ATTR 
    20222157 
    2023   CContextClient* CField::getContextClient() 
    2024   TRY 
    2025   { 
    2026     return client; 
    2027   } 
    2028   CATCH 
    2029  
    2030    
     2158  void CField::sendCloseDefinition(void) 
     2159  { 
     2160    CContext::getCurrent()->sendCloseDefinition(client) ; 
     2161  } 
     2162 
    20312163  void CField::sendFieldToFileServer(void) 
    20322164  { 
     
    20372169    this->sendAddAllVariables(client); 
    20382170  } 
     2171 
     2172  void CField::sendFieldToCouplerOut(void) 
     2173  { 
     2174    if (sendFieldToCouplerOut_done_) return ; 
     2175    else sendFieldToCouplerOut_done_=true ; 
     2176    grid_->sendGridToCouplerOut(client, this->getId()); 
     2177    this->sendGridCompleted(); 
     2178 
     2179  } 
    20392180   
     2181  void CField::makeGridAliasForCoupling(void)  
     2182  {  
     2183    grid_->makeAliasForCoupling(this->getId());  
     2184  } 
     2185 
     2186 //! Client side: Send a message  announcing that the grid definition has been received from a coupling context 
     2187   void CField::sendGridCompleted(void) 
     2188   TRY 
     2189   { 
     2190      CEventClient event(getType(),EVENT_ID_GRID_COMPLETED); 
     2191 
     2192      if (client->isServerLeader()) 
     2193      { 
     2194        CMessage msg; 
     2195        msg<<this->getId(); 
     2196        for (auto& rank : client->getRanksServerLeader()) event.push(rank,1,msg); 
     2197        client->sendEvent(event); 
     2198      } 
     2199      else client->sendEvent(event); 
     2200   } 
     2201   CATCH_DUMP_ATTR 
     2202 
     2203   //! Server side: Receive a message announcing that the grid definition has been received from a coupling context 
     2204   void CField::recvGridCompleted(CEventServer& event) 
     2205   TRY 
     2206   { 
     2207      CBufferIn* buffer=event.subEvents.begin()->buffer; 
     2208      string id; 
     2209      *buffer>>id ; 
     2210      get(id)->recvGridCompleted(*buffer); 
     2211   } 
     2212   CATCH 
     2213 
     2214   //! Server side: Receive a message  message  announcing that the grid definition has been received from a coupling context 
     2215   void CField::recvGridCompleted(CBufferIn& buffer) 
     2216   TRY 
     2217   { 
     2218      setGridCompleted() ; 
     2219   } 
     2220   CATCH_DUMP_ATTR 
     2221 
     2222 
     2223 
     2224 
     2225 
    20402226  void CField::sendFieldToInputFileServer(void) 
    20412227  { 
     
    21452331  TRY 
    21462332  { 
    2147     bool isFieldRead  = getRelFile() && !getRelFile()->mode.isEmpty() && getRelFile()->mode == CFile::mode_attr::read; 
    2148     bool isFieldWrite = getRelFile() && ( getRelFile()->mode.isEmpty() ||  getRelFile()->mode == CFile::mode_attr::write); 
    2149     if (isFieldRead && !(operation.getValue() == "instant" || operation.getValue() == "once") )      
     2333    if (hasFileIn() && !(operation.getValue() == "instant" || operation.getValue() == "once") )      
    21502334      ERROR("void CField::checkTimeAttributes(void)", 
    21512335         << "Unsupported operation for field '" << getFieldOutputName() << "'." << std::endl 
     
    21562340      if (operation.getValue() == "instant") 
    21572341      { 
    2158         if (isFieldRead || isFieldWrite) freq_op.setValue(getRelFile()->output_freq.getValue()); 
     2342        if (hasFileIn() || hasFileOut()) freq_op.setValue(getRelFile()->output_freq.getValue()); 
    21592343        else freq_op=*freqOp ; 
    21602344      } 
    21612345      else freq_op.setValue(TimeStep); 
    21622346    } 
    2163     if (freq_offset.isEmpty()) freq_offset.setValue(isFieldRead ? NoneDu : (freq_op.getValue() - TimeStep)); 
     2347    if (freq_offset.isEmpty()) freq_offset.setValue(hasFileIn() ? NoneDu : (freq_op.getValue() - TimeStep)); 
    21642348  } 
    21652349  CATCH_DUMP_ATTR 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/field.hpp

    r1872 r1875  
    7878         { 
    7979           EVENT_ID_UPDATE_DATA, EVENT_ID_READ_DATA, EVENT_ID_READ_DATA_READY, 
    80            EVENT_ID_ADD_VARIABLE, EVENT_ID_ADD_VARIABLE_GROUP 
     80           EVENT_ID_ADD_VARIABLE, EVENT_ID_ADD_VARIABLE_GROUP, EVENT_ID_GRID_COMPLETED 
    8181         }; 
    8282 
     
    111111         std::map<int, StdSize> getGridDataBufferSize(CContextClient* client, bool bufferForWriting = false); 
    112112 
    113          void setContextClient(CContextClient* newContextClient); 
    114          CContextClient* getContextClient(); 
    115  
     113       public: 
     114          void makeGridAliasForCoupling(void) ; 
    116115       public: 
    117116         bool isActive(bool atCurrentTimestep = false) const; 
     
    144143 
    145144         void sendFieldToFileServer(void) ; 
     145         void sendCloseDefinition(void) ; 
     146       
     147      public: 
     148         void sendFieldToCouplerOut(void) ; 
     149      private: 
     150         bool sendFieldToCouplerOut_done_=false; 
     151      public: 
     152 
    146153         void sendFieldToInputFileServer(void) ; 
    147154 
     
    177184        void sendAllAttributesToServer(CContextClient* client) ;  
    178185        void sendUpdateData(const CArray<double,1>& data); 
    179         void sendUpdateData(const CArray<double,1>& data, CContextClient* client); 
     186        void sendUpdateData(Time timestamp, const CArray<double,1>& data, CContextClient* client); 
    180187        static void recvUpdateData(CEventServer& event); 
    181188        void recvUpdateData(std::map<int,CBufferIn*>& rankBuffers); 
     189        void recvUpdateDataFromClient(std::map<int,CBufferIn*>& rankBuffers); 
     190        void recvUpdateDataFromCoupler(std::map<int,CBufferIn*>& rankBuffers); 
     191         
    182192        void writeField(void); 
    183193        bool sendReadDataRequest(const CDate& tsDataRequested, CContextClient* client); 
     
    188198        static void recvReadDataReady(CEventServer& event); 
    189199        void recvReadDataReady(vector<int> ranks, vector<CBufferIn*> buffers); 
     200        void recvDataFromCoupler(vector<int> ranks, vector<CBufferIn*> buffers) ; 
    190201        void checkForLateDataFromServer(void); 
    191         void checkIfMustAutoTrigger(void); 
    192         void autoTriggerIfNeeded(void); 
     202        void checkForLateDataFromCoupler(void) ; 
     203 
     204        void checkIfMustAutoTrigger(void); // ym obsolete 
     205        void autoTriggerIfNeeded(void); //ym obsolete 
     206        void triggerLateField(void) ; 
     207 
    193208        void outputField(CArray<double,3>& fieldOut); 
    194209        void outputField(CArray<double,2>& fieldOut); 
     
    227242 
    228243        void connectToFileServer(CGarbageCollector& gc) ; 
     244        void connectToCouplerOut(CGarbageCollector& gc) ; 
     245        void connectToCouplerIn(CGarbageCollector& gc) ; 
    229246        void connectToModelInput(CGarbageCollector& gc) ; 
    230247        void connectToFileWriter(CGarbageCollector& gc) ; 
     
    241258                                                 map<CContextClient*,map<int,size_t>>& maxEventSize,  
    242259                                                 bool bufferForWriting) ; 
     260      private: 
     261          bool isGridCompleted_ = true ; 
     262      public: 
     263          bool isGridCompleted() { return isGridCompleted_ ;}  
     264          void setGridCompleted(void) { isGridCompleted_= true; } 
     265          void unsetGridCompleted(void) { isGridCompleted_ = false ;} 
     266       
     267      public:      
     268          void sendGridCompleted(void) ; 
     269      private:    
     270          static void recvGridCompleted(CEventServer& event); 
     271          void recvGridCompleted(CBufferIn& buffer); 
     272 
     273 
    243274      private: 
    244275        std::vector<CGrid*> getGridPath(void) ; 
     
    315346      private: 
    316347         CContextClient* client; 
     348      public: 
     349         void setContextClient(CContextClient* newContextClient); 
     350         CContextClient* getContextClient(void) {return client;} 
     351 
     352      private: 
    317353 
    318354         bool areAllReferenceSolved; 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.cpp

    r1871 r1875  
    102102   } 
    103103   CATCH 
     104    
     105   /*! 
     106    * Get the local data grid size, ie the size of the compressed grid (inside the workflow) 
     107    * \return The size od the compressed grid 
     108    */ 
     109    StdSize  CGrid::getLocalDataSize(void) { return getClientDistribution()->getLocalDataSize();} 
     110 
    104111 
    105112   /*! 
     
    326333   CATCH_DUMP_ATTR 
    327334 
     335   //ym obsolete -> to be removed later 
    328336   void CGrid::checkMaskIndex(bool doSendingIndex) 
    329337   TRY 
     
    334342       if (this->isChecked && doSendingIndex && !isIndexSent)  
    335343       {  
    336          if (isScalarGrid())  sendIndexScalarGrid(); 
    337          else  sendIndex(); 
     344         if (isScalarGrid())  /*sendIndexScalarGrid()*/; 
     345         else  /*sendIndex()*/; 
    338346         this->isIndexSent = true;  
    339347       } 
     
    14531461  CATCH_DUMP_ATTR 
    14541462 
    1455   void CGrid::sendIndexScalarGrid() 
    1456   TRY 
    1457   { 
     1463  void CGrid::sendIndexScalarGrid(CContextClient* client, const string& gridId) 
     1464  TRY 
     1465  { 
     1466    if (sendIndexScalarGrid_done_.count(client)!=0) return ; 
     1467    else sendIndexScalarGrid_done_.insert(client) ; 
     1468 
    14581469    CContext* context = CContext::getCurrent(); 
    1459     storeIndex_toSrv_.clear(); 
    1460     std::list<CContextClient*>::iterator it; 
    1461  
    1462     for (it=clients.begin(); it!=clients.end(); ++it) 
    1463     { 
    1464       CContextClient* client = *it; 
    1465       int receiverSize = client->serverSize; 
    1466  
    1467       CEventClient event(getType(), EVENT_ID_INDEX); 
    1468       list<CMessage> listMsg; 
    1469       list<CArray<size_t,1> > listOutIndex; 
    1470  
     1470     
     1471    string serverGridId = gridId.empty() ? serverGridId=this->getId() : serverGridId=gridId ; 
     1472 
     1473    int receiverSize = client->serverSize; 
     1474 
     1475    CEventClient event(getType(), EVENT_ID_INDEX); 
     1476    list<CMessage> listMsg; 
     1477    list<CArray<size_t,1> > listOutIndex; 
     1478 
     1479    if (client->isServerLeader()) 
     1480    { 
     1481      const std::list<int>& ranks = client->getRanksServerLeader(); 
     1482      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1483      { 
     1484        int rank = *itRank; 
     1485        int nb = 1; 
     1486        storeIndex_toSrv_[client].insert(std::make_pair(rank, CArray<int,1>(nb))); 
     1487        listOutIndex.push_back(CArray<size_t,1>(nb)); 
     1488 
     1489        CArray<int, 1>& outLocalIndexToServer = storeIndex_toSrv_[client][rank]; 
     1490        CArray<size_t, 1>& outGlobalIndexOnServer = listOutIndex.back(); 
     1491 
     1492        for (int k = 0; k < nb; ++k) 
     1493        { 
     1494          outGlobalIndexOnServer(k) = 0; 
     1495          outLocalIndexToServer(k)  = 0; 
     1496        } 
     1497 
     1498        if (context->getServiceType()==CServicesManager::CLIENT)  // -> what about for coupling probably unusefull to be check 
     1499          storeIndex_fromSrv_.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer))); 
     1500 
     1501        listMsg.push_back(CMessage()); 
     1502        listMsg.back() << serverGridId << isCompressible_ << listOutIndex.back(); 
     1503 
     1504        event.push(rank, 1, listMsg.back()); 
     1505      } 
     1506      client->sendEvent(event); 
     1507    } 
     1508    else 
     1509    { 
     1510      const std::list<int>& ranks = client->getRanksServerNotLeader(); 
     1511      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1512      { 
     1513        int rank = *itRank; 
     1514        int nb = 1;           
     1515        CArray<int, 1> outLocalIndexToServer(nb); 
     1516        for (int k = 0; k < nb; ++k) 
     1517        { 
     1518          outLocalIndexToServer(k)  = 0; 
     1519        } 
     1520 
     1521        if (context->getServiceType()==CServicesManager::CLIENT) 
     1522          storeIndex_fromSrv_.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer))); 
     1523      } 
     1524      client->sendEvent(event); 
     1525    } 
     1526  } 
     1527  CATCH_DUMP_ATTR 
     1528 
     1529  void CGrid::sendIndex(CContextClient* client, const string& gridId) 
     1530  TRY 
     1531  { 
     1532    if (sendIndex_done_.count(client)!=0) return ; 
     1533    else sendIndex_done_.insert(client) ; 
     1534    CContext* context = CContext::getCurrent(); 
     1535    string serverGridId = gridId.empty() ? this->getId() : gridId ; 
     1536 
     1537 
     1538 
     1539    int receiverSize = client->serverSize; 
     1540 
     1541    CEventClient event(getType(), EVENT_ID_INDEX); 
     1542    int rank; 
     1543    list<CMessage> listMsg; 
     1544    list<CArray<size_t,1> > listOutIndex; 
     1545    const CDistributionClient::GlobalLocalDataMap& globalLocalIndexSendToServer = getClientDistribution()->getGlobalLocalDataSendToServer(); 
     1546    CDistributionClient::GlobalLocalDataMap::const_iterator itbIndex = globalLocalIndexSendToServer.begin(), itIndex, 
     1547                                                            iteIndex = globalLocalIndexSendToServer.end(); 
     1548    itIndex = itbIndex;                                                               
     1549 
     1550    if (!doGridHaveDataDistributed(client)) 
     1551    { 
    14711552      if (client->isServerLeader()) 
    14721553      { 
     1554        int indexSize = globalLocalIndexSendToServer.size(); 
     1555        CArray<size_t,1> outGlobalIndexOnServer(indexSize); 
     1556        CArray<int,1> outLocalIndexToServer(indexSize); 
     1557        for (int idx = 0; itIndex != iteIndex; ++itIndex, ++idx) 
     1558        { 
     1559          outGlobalIndexOnServer(idx) = itIndex->first; 
     1560          outLocalIndexToServer(idx) = itIndex->second; 
     1561        } 
     1562 
    14731563        const std::list<int>& ranks = client->getRanksServerLeader(); 
    14741564        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    14751565        { 
    1476           int rank = *itRank; 
    1477           int nb = 1; 
    1478           storeIndex_toSrv_[client].insert(std::make_pair(rank, CArray<int,1>(nb))); 
    1479           listOutIndex.push_back(CArray<size_t,1>(nb)); 
    1480  
    1481           CArray<int, 1>& outLocalIndexToServer = storeIndex_toSrv_[client][rank]; 
    1482           CArray<size_t, 1>& outGlobalIndexOnServer = listOutIndex.back(); 
    1483  
    1484           for (int k = 0; k < nb; ++k) 
    1485           { 
    1486             outGlobalIndexOnServer(k) = 0; 
    1487             outLocalIndexToServer(k)  = 0; 
    1488           } 
    1489  
    1490           if (context->getServiceType()==CServicesManager::CLIENT)   
    1491             storeIndex_fromSrv_.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer))); 
     1566          storeIndex_toSrv_[client].insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer))); 
     1567          if (context->getServiceType()==CServicesManager::CLIENT)  // -> what about for coupling probably unusefull to be check 
     1568            storeIndex_fromSrv_.insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer))); 
     1569           
     1570          listOutIndex.push_back(CArray<size_t,1>(outGlobalIndexOnServer)); 
    14921571 
    14931572          listMsg.push_back(CMessage()); 
    1494           listMsg.back() << getId( )<< isCompressible_ << listOutIndex.back(); 
    1495  
    1496           event.push(rank, 1, listMsg.back()); 
     1573          listMsg.back() << serverGridId << isCompressible_ << listOutIndex.back(); 
     1574 
     1575          event.push(*itRank, 1, listMsg.back()); 
    14971576        } 
    14981577        client->sendEvent(event); 
     
    15001579      else 
    15011580      { 
    1502         const std::list<int>& ranks = client->getRanksServerNotLeader(); 
    1503         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1581         int indexSize = globalLocalIndexSendToServer.size(); 
     1582         CArray<int,1> outLocalIndexToServer(indexSize); 
     1583         for (int idx = 0; itIndex != iteIndex; ++itIndex, ++idx) 
     1584         { 
     1585           outLocalIndexToServer(idx) = itIndex->second; 
     1586         } 
     1587 
     1588         const std::list<int>& ranks = client->getRanksServerNotLeader(); 
     1589         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1590         { 
     1591           storeIndex_fromSrv_.insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer))); 
     1592         } 
     1593         client->sendEvent(event); 
     1594       } 
     1595    } 
     1596    else 
     1597    { 
     1598      CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itGlobalMap; 
     1599      itGlobalMap = globalIndexOnServer_[receiverSize].begin(); 
     1600      iteGlobalMap = globalIndexOnServer_[receiverSize].end(); 
     1601 
     1602      std::map<int,std::vector<int> >localIndexTmp; 
     1603      std::map<int,std::vector<size_t> > globalIndexTmp; 
     1604      for (; itGlobalMap != iteGlobalMap; ++itGlobalMap) 
     1605      { 
     1606        int serverRank = itGlobalMap->first; 
     1607        int indexSize = itGlobalMap->second.size(); 
     1608        const std::vector<size_t>& indexVec = itGlobalMap->second; 
     1609        for (int idx = 0; idx < indexSize; ++idx) 
    15041610        { 
    1505           int rank = *itRank; 
    1506           int nb = 1;           
    1507           CArray<int, 1> outLocalIndexToServer(nb); 
    1508           for (int k = 0; k < nb; ++k) 
     1611          itIndex = globalLocalIndexSendToServer.find(indexVec[idx]); 
     1612          if (iteIndex != itIndex) 
    15091613          { 
    1510             outLocalIndexToServer(k)  = 0; 
    1511           } 
    1512  
    1513           if (context->getServiceType()==CServicesManager::CLIENT) 
    1514             storeIndex_fromSrv_.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer))); 
    1515         } 
    1516         client->sendEvent(event); 
    1517       } 
    1518     } 
    1519   } 
    1520   CATCH_DUMP_ATTR 
    1521  
    1522   void CGrid::sendIndex(void) 
    1523   TRY 
    1524   { 
    1525     CContext* context = CContext::getCurrent(); 
    1526     storeIndex_toSrv_.clear(); 
    1527     std::list<CContextClient*>::iterator it; 
    1528  
    1529     for (it=clients.begin(); it!=clients.end(); ++it) 
    1530     { 
    1531       CContextClient* client = *it; 
    1532       int receiverSize = client->serverSize; 
    1533  
    1534       CEventClient event(getType(), EVENT_ID_INDEX); 
    1535       int rank; 
    1536       list<CMessage> listMsg; 
    1537       list<CArray<size_t,1> > listOutIndex; 
    1538       const CDistributionClient::GlobalLocalDataMap& globalLocalIndexSendToServer = getClientDistribution()->getGlobalLocalDataSendToServer(); 
    1539       CDistributionClient::GlobalLocalDataMap::const_iterator itbIndex = globalLocalIndexSendToServer.begin(), itIndex, 
    1540                                                               iteIndex = globalLocalIndexSendToServer.end(); 
    1541       itIndex = itbIndex;                                                               
    1542  
    1543       if (!doGridHaveDataDistributed(client)) 
    1544       { 
    1545         if (client->isServerLeader()) 
    1546         { 
    1547           int indexSize = globalLocalIndexSendToServer.size(); 
    1548           CArray<size_t,1> outGlobalIndexOnServer(indexSize); 
    1549           CArray<int,1> outLocalIndexToServer(indexSize); 
    1550           for (int idx = 0; itIndex != iteIndex; ++itIndex, ++idx) 
    1551           { 
    1552             outGlobalIndexOnServer(idx) = itIndex->first; 
    1553             outLocalIndexToServer(idx) = itIndex->second; 
    1554           } 
    1555  
    1556           const std::list<int>& ranks = client->getRanksServerLeader(); 
    1557           for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1558           { 
    1559             storeIndex_toSrv_[client].insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer))); 
    1560             if (context->getServiceType()==CServicesManager::CLIENT) 
    1561               storeIndex_fromSrv_.insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer))); 
    1562              
    1563             listOutIndex.push_back(CArray<size_t,1>(outGlobalIndexOnServer)); 
    1564  
    1565             listMsg.push_back(CMessage()); 
    1566             listMsg.back() << getId() << isCompressible_ << listOutIndex.back(); 
    1567  
    1568             event.push(*itRank, 1, listMsg.back()); 
    1569           } 
    1570           client->sendEvent(event); 
    1571         } 
    1572         else 
    1573         { 
    1574            int indexSize = globalLocalIndexSendToServer.size(); 
    1575            CArray<int,1> outLocalIndexToServer(indexSize); 
    1576            for (int idx = 0; itIndex != iteIndex; ++itIndex, ++idx) 
    1577            { 
    1578              outLocalIndexToServer(idx) = itIndex->second; 
    1579            } 
    1580  
    1581            const std::list<int>& ranks = client->getRanksServerNotLeader(); 
    1582            for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1583            { 
    1584              storeIndex_fromSrv_.insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer))); 
    1585            } 
    1586            client->sendEvent(event); 
    1587          } 
    1588       } 
    1589       else 
    1590       { 
    1591         CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itGlobalMap; 
    1592         itGlobalMap = globalIndexOnServer_[receiverSize].begin(); 
    1593         iteGlobalMap = globalIndexOnServer_[receiverSize].end(); 
    1594  
    1595         std::map<int,std::vector<int> >localIndexTmp; 
    1596         std::map<int,std::vector<size_t> > globalIndexTmp; 
    1597         for (; itGlobalMap != iteGlobalMap; ++itGlobalMap) 
    1598         { 
    1599           int serverRank = itGlobalMap->first; 
    1600           int indexSize = itGlobalMap->second.size(); 
    1601           const std::vector<size_t>& indexVec = itGlobalMap->second; 
    1602           for (int idx = 0; idx < indexSize; ++idx) 
    1603           { 
    1604             itIndex = globalLocalIndexSendToServer.find(indexVec[idx]); 
    1605             if (iteIndex != itIndex) 
    1606             { 
    1607               globalIndexTmp[serverRank].push_back(itIndex->first); 
    1608               localIndexTmp[serverRank].push_back(itIndex->second); 
    1609             } 
     1614            globalIndexTmp[serverRank].push_back(itIndex->first); 
     1615            localIndexTmp[serverRank].push_back(itIndex->second); 
    16101616          } 
    16111617        } 
    1612  
    1613         for (int ns = 0; ns < connectedServerRank_[receiverSize].size(); ++ns) 
     1618      } 
     1619 
     1620      for (int ns = 0; ns < connectedServerRank_[receiverSize].size(); ++ns) 
     1621      { 
     1622        rank = connectedServerRank_[receiverSize][ns]; 
     1623        int nb = 0; 
     1624        if (globalIndexTmp.end() != globalIndexTmp.find(rank)) 
     1625          nb = globalIndexTmp[rank].size(); 
     1626 
     1627        storeIndex_toSrv_[client].insert(make_pair(rank, CArray<int,1>(nb))); 
     1628        listOutIndex.push_back(CArray<size_t,1>(nb)); 
     1629 
     1630        CArray<int, 1>& outLocalIndexToServer = storeIndex_toSrv_[client][rank]; 
     1631        CArray<size_t, 1>& outGlobalIndexOnServer = listOutIndex.back(); 
     1632 
     1633        for (int k = 0; k < nb; ++k) 
    16141634        { 
    1615           rank = connectedServerRank_[receiverSize][ns]; 
    1616           int nb = 0; 
    1617           if (globalIndexTmp.end() != globalIndexTmp.find(rank)) 
    1618             nb = globalIndexTmp[rank].size(); 
    1619  
    1620           storeIndex_toSrv_[client].insert(make_pair(rank, CArray<int,1>(nb))); 
    1621           listOutIndex.push_back(CArray<size_t,1>(nb)); 
    1622  
    1623           CArray<int, 1>& outLocalIndexToServer = storeIndex_toSrv_[client][rank]; 
    1624           CArray<size_t, 1>& outGlobalIndexOnServer = listOutIndex.back(); 
    1625  
    1626           for (int k = 0; k < nb; ++k) 
    1627           { 
    1628             outGlobalIndexOnServer(k) = globalIndexTmp[rank].at(k); 
    1629             outLocalIndexToServer(k)  = localIndexTmp[rank].at(k); 
    1630           } 
    1631  
    1632           storeIndex_fromSrv_.insert(make_pair(rank, CArray<int,1>(outLocalIndexToServer))); 
    1633           listMsg.push_back(CMessage()); 
    1634           listMsg.back() << getId()  << isCompressible_ << listOutIndex.back(); 
    1635  
    1636           event.push(rank, nbSenders_[receiverSize][rank], listMsg.back()); 
     1635          outGlobalIndexOnServer(k) = globalIndexTmp[rank].at(k); 
     1636          outLocalIndexToServer(k)  = localIndexTmp[rank].at(k); 
    16371637        } 
    16381638 
    1639         client->sendEvent(event); 
    1640       } 
     1639        storeIndex_fromSrv_.insert(make_pair(rank, CArray<int,1>(outLocalIndexToServer))); 
     1640        listMsg.push_back(CMessage()); 
     1641        listMsg.back() << serverGridId  << isCompressible_ << listOutIndex.back(); 
     1642 
     1643        event.push(rank, nbSenders_[receiverSize][rank], listMsg.back()); 
     1644      } 
     1645      client->sendEvent(event); 
    16411646    } 
    16421647  } 
     
    22352240    gridPtr->sendCreateChild(this->getId(),client); 
    22362241    this->sendAllAttributesToServer(client); 
    2237     if (isScalarGrid())  sendIndexScalarGrid(); 
    2238     else  sendIndex(); 
     2242    if (isScalarGrid())  sendIndexScalarGrid(client); 
     2243    else  sendIndex(client); 
    22392244    this->sendAllDomains(client); 
    22402245    this->sendAllAxis(client); 
    22412246    this->sendAllScalars(client); 
     2247  } 
     2248 
     2249  void CGrid::sendGridToCouplerOut(CContextClient* client, const string& fieldId) 
     2250  { 
     2251    if (sendGridToCouplerOut_done_.count(client)!=0) return ; 
     2252    else sendGridToCouplerOut_done_.insert(client) ; 
     2253    string gridId="_grid_of_"+fieldId ; 
     2254    this->sendAllAttributesToServer(client, gridId); 
     2255     
     2256    if (isScalarGrid())  sendIndexScalarGrid(client, gridId); 
     2257    else sendIndex(client, gridId); 
     2258 
     2259    const auto& domVect = getDomains() ; 
     2260    for (int pos=0; pos<domVect.size();pos++) domVect[pos]->sendDomainToCouplerOut(client, fieldId, pos); 
     2261 
     2262    const auto& axisVect=getAxis() ; 
     2263    for (int pos=0; pos<axisVect.size();pos++) axisVect[pos]->sendAxisToCouplerOut(client, getGlobalDimension(), getAxisPositionInGrid()[pos], fieldId, pos); 
     2264 
     2265    const auto& scalVect=getScalars() ; 
     2266    for (int pos=0; pos<scalVect.size();pos++) scalVect[pos]->sendScalarToCouplerOut(client, fieldId, pos); 
     2267  } 
     2268 
     2269  void CGrid::makeAliasForCoupling(const string& fieldId) 
     2270  { 
     2271    string gridId="_grid_of_"+fieldId ; 
     2272    createAlias(gridId) ; 
     2273     
     2274    const auto& domVect = getDomains() ; 
     2275    for (int pos=0; pos<domVect.size();pos++) domVect[pos]->makeAliasForCoupling(fieldId, pos); 
     2276 
     2277    const auto& axisVect=getAxis() ; 
     2278    for (int pos=0; pos<axisVect.size();pos++) axisVect[pos]->makeAliasForCoupling(fieldId, pos); 
     2279 
     2280    const auto& scalVect=getScalars() ; 
     2281    for (int pos=0; pos<scalVect.size();pos++) scalVect[pos]->makeAliasForCoupling(fieldId, pos); 
    22422282  } 
    22432283 
     
    23652405  other context (coupling) 
    23662406  */ 
    2367   bool CGrid::checkIfCompleted(void) 
     2407  bool CGrid::isCompleted(void) 
    23682408  { 
    23692409    setDomainList(); 
    2370     for (auto domainId : domList_) if (!CDomain::get(domainId)->checkIfCompleted()) return false ; 
     2410    for (auto domainId : domList_) if (!CDomain::get(domainId)->isCompleted()) return false ; 
    23712411    setAxisList() ; 
    2372     for (auto axisId : axisList_) if (!CAxis::get(axisId)->checkIfCompleted()) return false ; 
     2412    for (auto axisId : axisList_) if (!CAxis::get(axisId)->isCompleted()) return false ; 
    23732413    setScalarList() ; 
    2374     for (auto scalarId : scalarList_) if (!CScalar::get(scalarId)->checkIfCompleted()) return false ; 
     2414    for (auto scalarId : scalarList_) if (!CScalar::get(scalarId)->isCompleted()) return false ; 
    23752415    return true ; 
     2416  } 
     2417 
     2418  /*! 
     2419  \brief impose that all elements of the grid are complete 
     2420  Before make any grid processing, we must be sure that all grid information elements have 
     2421  been sent, for exemple when reading a grid in a file or when grid elements are sent by an 
     2422  other context (coupling) 
     2423  */ 
     2424  void CGrid::setCompleted(void) 
     2425  { 
     2426    setDomainList(); 
     2427    for (auto domainId : domList_) CDomain::get(domainId)->setCompleted() ; 
     2428    setAxisList() ; 
     2429    for (auto axisId : axisList_) CAxis::get(axisId)->setCompleted() ; 
     2430    setScalarList() ; 
     2431    for (auto scalarId : scalarList_) CScalar::get(scalarId)->setCompleted() ; 
     2432  } 
     2433 
     2434/*! 
     2435  \brief impose that all elements of the grid are incomplete 
     2436  Before make any grid processing, we must be sure that all grid information elements have 
     2437  been sent, for exemple when reading a grid in a file or when grid elements are sent by an 
     2438  other context (coupling) 
     2439  */ 
     2440  void CGrid::unsetCompleted(void) 
     2441  { 
     2442    setDomainList(); 
     2443    for (auto domainId : domList_) CDomain::get(domainId)->unsetCompleted() ; 
     2444    setAxisList() ; 
     2445    for (auto axisId : axisList_) CAxis::get(axisId)->unsetCompleted() ; 
     2446    setScalarList() ; 
     2447    for (auto scalarId : scalarList_) CScalar::get(scalarId)->unsetCompleted() ; 
    23762448  } 
    23772449 
     
    29042976      clientsSet.insert(contextClient); 
    29052977    } 
    2906     for (int i=0; i<this->getDomains().size(); i++) 
    2907         this->getDomains()[i]->setContextClient(contextClient); 
    2908     for (int i=0; i<this->getAxis().size(); i++) 
    2909         this->getAxis()[i]->setContextClient(contextClient); 
     2978    for (auto domain : getDomains()) domain->setContextClient(contextClient); 
     2979    for (auto axis : getAxis()) axis->setContextClient(contextClient); 
     2980    for (auto scalar : getScalars()) scalar->setContextClient(contextClient); 
     2981    
    29102982  } 
    29112983  CATCH_DUMP_ATTR 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.hpp

    r1872 r1875  
    9090 
    9191         StdSize  getDataSize(void) ; 
     92 
     93         /** 
     94          * Get the local data grid size, ie the size of the compressed grid (inside the workflow) 
     95          * \return The size od the compressed grid 
     96          */ 
     97         StdSize  getLocalDataSize(void) ; 
    9298 
    9399         /// Entrees-sorties de champs 
     
    151157      private: 
    152158         std::set<CContextClient*> sendGridToFileServer_done_ ; 
    153        
     159      
     160      public: 
     161         void sendGridToCouplerOut(CContextClient* client, const string& fieldId) ; 
     162      private: 
     163         std::set<CContextClient*> sendGridToCouplerOut_done_ ; 
     164 
     165      public: 
     166         void makeAliasForCoupling(const string& fieldId) ; 
     167 
    154168      public: 
    155169         void sendAddDomain(const std::string& id,CContextClient* contextClient); 
     
    170184         static void recvIndex(CEventServer& event); 
    171185         void recvIndex(vector<int> ranks, vector<CBufferIn*> buffers, CContextServer* server); 
    172          void sendIndex(void); 
    173          void sendIndexScalarGrid(); 
    174  
     186        
     187       public:   
     188         void sendIndex(CContextClient* client, const string& gridId=""); 
     189       private: 
     190          set<CContextClient*> sendIndex_done_ ; 
     191        
     192       public: 
     193         void sendIndexScalarGrid(CContextClient* client, const string& gridId=""); 
     194       private: 
     195          set<CContextClient*> sendIndexScalarGrid_done_ ; 
     196       
     197       public: 
    175198         void setContextClient(CContextClient* contextClient); 
    176199 
     
    221244         bool hasTransform(); 
    222245         size_t getGlobalWrittenSize(void) ; 
    223          bool checkIfCompleted(void) ; 
     246          
     247         bool isCompleted(void) ; 
     248         void setCompleted(void) ; 
     249         void unsetCompleted(void) ; 
    224250 
    225251 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/scalar.cpp

    r1870 r1875  
    6868 
    6969  } 
    70  
    71   /*! 
    72   \brief Check if a scalar is completed 
    73   Before make any scalar processing, we must be sure that all scalar informations have 
    74   been sent, for exemple when reading a grid in a file or when grid elements are sent by an 
    75   other context (coupling). So all direct reference of the scalar (scalar_ref) must be also completed 
    76   \return true if scalar and scalar reference are completed 
    77   */ 
    78   bool CScalar::checkIfCompleted(void) 
    79   { 
    80     if (hasDirectScalarReference()) if (!getDirectScalarReference()->checkIfCompleted()) return false; 
    81     return isCompleted_ ; 
    82   } 
    83  
    84   /*! 
    85   \brief Set a scalar as completed 
    86    When all information about a scalar have been received, the scalar is tagged as completed and is 
    87    suitable for processing 
    88   */ 
    89   void CScalar::setCompleted(void) 
    90   { 
    91     if (hasDirectScalarReference()) getDirectScalarReference()->setCompleted() ; 
    92     isCompleted_=true ; 
    93   } 
    94  
    95   /*! 
    96   \brief Set a scalar as uncompleted 
    97    When informations about a scalar are expected from a grid reading from file or coupling, the scalar is  
    98    tagged as uncompleted and is not suitable for processing 
    99   */ 
    100   void CScalar::setUncompleted(void) 
    101   { 
    102     if (hasDirectScalarReference()) getDirectScalarReference()->setUncompleted() ; 
    103     isCompleted_=false ; 
    104   } 
    105  
    106  
    107  
    10870 
    10971  /*! 
     
    187149        refScalar[i]->setTransformations(scalar->getAllTransformations()); 
    188150  } 
    189  
     151  
    190152  void CScalar::sendScalarToFileServer(CContextClient* client) 
    191153  { 
    192154    if (sendScalarToFileServer_done_.count(client)!=0) return ; 
    193155    else sendScalarToFileServer_done_.insert(client) ; 
    194  
    195156    StdString scalarDefRoot("scalar_definition"); 
    196157    CScalarGroup* scalarPtr = CScalarGroup::get(scalarDefRoot); 
    197158    this->sendAllAttributesToServer(client); 
    198159  } 
     160 
     161  void CScalar::sendScalarToCouplerOut(CContextClient* client, const string& fieldId, int posInGrid) 
     162  { 
     163    if (sendScalarToCouplerOut_done_.count(client)!=0) return ; 
     164    else sendScalarToCouplerOut_done_.insert(client) ; 
     165 
     166    string scalarId="_scalar["+std::to_string(posInGrid)+"]_of_"+fieldId ; 
     167    
     168    if (!scalar_ref.isEmpty()) 
     169    { 
     170      auto scalar_ref_tmp=scalar_ref.getValue() ; 
     171      scalar_ref.reset() ; // remove the reference, find an other way to do that more cleanly 
     172      this->sendAllAttributesToServer(client, scalarId)  ; 
     173      scalar_ref = scalar_ref_tmp ; 
     174    } 
     175    else this->sendAllAttributesToServer(client, scalarId)  ; 
     176 
     177 
     178    this->sendAllAttributesToServer(client, scalarId); 
     179  }   
     180 
     181  void CScalar::makeAliasForCoupling(const string& fieldId, int posInGrid) 
     182  { 
     183    const string scalarId = "_scalar["+std::to_string(posInGrid)+"]_of_"+fieldId ; 
     184    this->createAlias(scalarId) ; 
     185  } 
     186 
     187  void CScalar::setContextClient(CContextClient* contextClient) 
     188  TRY 
     189  { 
     190    if (clientsSet.find(contextClient)==clientsSet.end()) 
     191    { 
     192      clients.push_back(contextClient) ; 
     193      clientsSet.insert(contextClient); 
     194    } 
     195  } 
     196  CATCH_DUMP_ATTR 
    199197  /*! 
    200198    Parse children nodes of a scalar in xml file. 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/scalar.hpp

    r1870 r1875  
    7272            void checkAttributesOnClient(); 
    7373            virtual void parse(xml::CXMLNode & node); 
    74  
    75             bool checkIfCompleted(void) ; 
    76             void setCompleted(void) ; 
    77             void setUncompleted(void) ; 
    78           
     74         
    7975         public: 
    8076            void sendScalarToFileServer(CContextClient* client) ; 
    8177         private: 
    8278            std::set<CContextClient*> sendScalarToFileServer_done_ ; 
     79 
     80         public: 
     81            void sendScalarToCouplerOut(CContextClient* client, const string& fieldId, int posInGrid) ; 
     82         private: 
     83            std::set<CContextClient*> sendScalarToCouplerOut_done_ ; 
     84          
     85         public: 
     86            void makeAliasForCoupling(const string& fieldId, int posInGrid) ; 
    8387 
    8488         public: 
     
    8993           CTransformation<CScalar>* addTransformation(ETranformationType transType, const StdString& id=""); 
    9094           bool isEqual(CScalar* scalar); 
    91  
     95        private:   
     96          /** Clients that have to send a scalar. There can be multiple clients in case of secondary server, otherwise only one client. */ 
     97         std::list<CContextClient*> clients; 
     98         std::set<CContextClient*> clientsSet; 
     99        public: 
     100          void setContextClient(CContextClient* contextClient) ; 
     101         
    92102         private: 
    93103           std::set<StdString> relFiles; 
     
    103113           /** define if the scalar is completed or not ie all attributes have been received before in case  
    104114               of grid reading from file or coupling */  
    105            bool isCompleted_=true ;   
     115      private: 
     116         /** define if the scalar is completed or not ie all attributes have been received before in case  
     117             of grid reading from file or coupling */  
     118         bool isCompleted_=true ;   
     119      public:      
     120         /*! 
     121           \brief Check if a scalar is completed 
     122           Before make any scalar processing, we must be sure that all scalar informations have 
     123           been sent, for exemple when reading a grid in a file or when grid elements are sent by an 
     124           other context (coupling). So all direct reference of the scalar (scalar_ref) must be also completed 
     125           \return true if scalar and scalar reference are completed 
     126          */ 
     127         bool isCompleted(void) 
     128         { 
     129           if (hasDirectScalarReference()) if (!getDirectScalarReference()->isCompleted()) return false; 
     130           else return isCompleted_ ; 
     131         } 
     132         void setCompleted(void) { isCompleted_=true ; } 
     133         void unsetCompleted(void) { isCompleted_=false ; } 
    106134 
     135      private: 
    107136            DECLARE_REF_FUNC(Scalar,scalar) 
    108137 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/object_template.hpp

    r1869 r1875  
    5656         static void ClearAllAttributes(void); 
    5757         std::map<int, size_t> getMinimumBufferSizeForAttributes(CContextClient* client); 
    58          void sendAttributToServer(const string& id, CContextClient* client); 
    59          void sendAttributToServer(CAttribute& attr, CContextClient* client) ; 
    60          void sendAllAttributesToServer(CContextClient* client); 
    61          void sendAddItem(const string& id, int itemType, CContextClient* client); 
     58         void sendAttributToServer(const string& id, CContextClient* client, const string& objectId=""); 
     59         void sendAttributToServer(CAttribute& attr, CContextClient* client, const string& objectId="") ; 
     60         void sendAllAttributesToServer(CContextClient* client, const string& objectId=""); 
     61         void sendAddItem(const string& id, int itemType, CContextClient* client, const string& objectId=""); 
    6262         static void recvAttributFromClient(CEventServer& event) ; 
    6363         static bool dispatchEvent(CEventServer& event) ; 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/object_template_impl.hpp

    r1869 r1875  
    216216 
    217217   template<typename T> 
    218    void CObjectTemplate<T>::sendAllAttributesToServer(CContextClient* client) 
     218   void CObjectTemplate<T>::sendAllAttributesToServer(CContextClient* client, const string& objectId) 
    219219   { 
    220220     CAttributeMap& attrMap = *this; 
     
    222222     for (; it != itE; ++it) 
    223223     { 
    224        if (it->second->doSend() && !(it->second)->isEmpty()) sendAttributToServer(*(it->second), client); 
     224       if (it->second->doSend() && !(it->second)->isEmpty()) sendAttributToServer(*(it->second), client, objectId); 
    225225     } 
    226226   } 
    227227 
    228228   template <class T> 
    229    void CObjectTemplate<T>::sendAttributToServer(const string& id, CContextClient* client) 
     229   void CObjectTemplate<T>::sendAttributToServer(const string& id, CContextClient* client, const string& objectId ) 
    230230   { 
    231231      CAttributeMap & attrMap = *this; 
     
    235235 
    236236  template <class T> 
    237   void CObjectTemplate<T>::sendAttributToServer(CAttribute& attr, CContextClient* client) 
     237  void CObjectTemplate<T>::sendAttributToServer(CAttribute& attr, CContextClient* client, const string& objectId) 
    238238  { 
    239239    CEventClient event(getType(),EVENT_ID_SEND_ATTRIBUTE); 
     
    241241    { 
    242242      CMessage msg; 
    243       msg<<this->getId();  
     243      if (objectId.empty()) msg << this->getId(); 
     244      else msg << objectId; 
    244245      msg << attr.getName(); 
    245246      msg << attr; 
     
    254255/* specialisation for context, because context Id on client is not the same on server, and no need to transfer context Id */ 
    255256  template <> 
    256   void CObjectTemplate<CContext>::sendAttributToServer(CAttribute& attr, CContextClient* client) 
     257  void CObjectTemplate<CContext>::sendAttributToServer(CAttribute& attr, CContextClient* client, const string& objectId) 
    257258  { 
    258259    CEventClient event(getType(),EVENT_ID_SEND_ATTRIBUTE); 
     
    278279 
    279280  template<class T> 
    280   void CObjectTemplate<T>::sendAddItem(const StdString& id, int itemType, CContextClient* client) 
     281  void CObjectTemplate<T>::sendAddItem(const StdString& id, int itemType, CContextClient* client, const string& objectId) 
    281282  { 
    282283    typedef typename T::EEventId ItemType; 
     
    285286     { 
    286287       CMessage msg; 
    287        msg << this->getId(); 
     288       if (objectId.empty()) msg << this->getId(); 
     289       else msg << objectId; 
    288290       msg << id; 
    289291       const std::list<int>& ranks = client->getRanksServerLeader(); 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/test/generic_testcase.f90

    r1869 r1875  
    18601860        bounds_lon(3,i,j)=bounds_lon_glo(1,ibegin+i) 
    18611861        bounds_lon(4,i,j)=bounds_lon_glo(2,ibegin+i) 
    1862         bounds_lat(1,i,j)=bounds_lat_glo(1,ibegin+i) 
    1863         bounds_lat(2,i,j)=bounds_lat_glo(1,ibegin+i) 
    1864         bounds_lat(3,i,j)=bounds_lat_glo(2,ibegin+i) 
    1865         bounds_lat(4,i,j)=bounds_lat_glo(2,ibegin+i) 
     1862        bounds_lat(1,i,j)=bounds_lat_glo(1,jbegin+j) 
     1863        bounds_lat(2,i,j)=bounds_lat_glo(1,jbegin+j) 
     1864        bounds_lat(3,i,j)=bounds_lat_glo(2,jbegin+j) 
     1865        bounds_lat(4,i,j)=bounds_lat_glo(2,jbegin+j) 
    18661866 
    18671867        ij=(j+offset_j)*(ni+2*offset_i)+i+offset_i 
     
    19081908      CALL xios_set_domain_attr(TRIM(domain_id), nj_glo=nj_glo, jbegin=jbegin, nj=nj, data_jbegin=-offset_j, data_nj=nj+2*offset_j) 
    19091909      CALL xios_set_domain_attr(TRIM(domain_id), data_dim=2, lonvalue_2d=lon, latvalue_2d=lat, mask_1d=return_mask) 
     1910      CALL xios_set_domain_attr(TRIM(domain_id), bounds_lon_2d=bounds_lon, bounds_lat_2d=bounds_lat, nvertex=4) 
    19101911    ENDIF 
    19111912 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/domain_algorithm_interpolate.cpp

    r1787 r1875  
    171171      step=(domainSrc_->lat_end-domainSrc_->lat_start)/domainSrc_->nj_glo ; 
    172172      for (int i=0; i<domainSrc_->ni_glo; ++i) lat_g(i)=domainSrc_->lat_start+i*step ; 
     173    } 
     174    else if (!domainSrc_->lonvalue.isEmpty() && !domainSrc_->latvalue.isEmpty())  // data can come possibly from coupler so only lonvalue and latvalue are defined ? 
     175    { 
     176      CArray<double,1> lon(niSrc), lat(njSrc) ; 
     177      for(int i=0; i< niSrc;++i) lon(i) = domainSrc_->lonvalue(i) ; 
     178      for(int j=0, n=0; j<njSrc; ++j, n+=niSrc) lat(j) = domainSrc_->latvalue(n) ; 
     179      domainSrc_->AllgatherRectilinearLonLat(lon, lat, lon_g, lat_g) ; 
    173180    } 
    174181    else ERROR("void CDomainAlgorithmInterpolate::computeRemap()",<<"Cannot compute bounds for rectilinear domain") ; 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/type/type_decl.cpp

    r1509 r1875  
    3333   
    3434  macro(string) 
     35  macro(char) 
     36  macro(short) 
    3537  macro(int) 
     38  macro(unsigned int) 
     39  macro(long) 
     40  macro(unsigned long) 
     41  macro(long long) 
     42  macro(unsigned long long) 
    3643  macro(double) 
    3744  macro(bool) 
    38   macro(StdSize) 
    3945  macro(CDate) 
    4046  macro(CDuration) 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/type/type_util.hpp

    r1782 r1875  
    7676  macro(unsigned int) 
    7777  macro(long) 
     78  macro(long long) 
    7879  macro(unsigned long) 
     80  macro(unsigned long long) 
    7981  macro(float) 
    8082  macro(double) 
  • XIOS/dev/dev_ym/XIOS_COUPLING/src/xios_spl.hpp

    r1622 r1875  
    4949typedef std::size_t        StdSize; 
    5050 
    51 typedef  unsigned short int   ushort; 
    52 typedef  unsigned int         uint; 
    53 typedef  unsigned long int    ulong; 
     51typedef  unsigned short int      ushort; 
     52typedef  unsigned int            uint; 
     53typedef  unsigned long int       ulong; 
     54typedef  long long int           longlong; 
     55typedef  unsigned long long int  ulonglong; 
    5456 
    5557const size_t stringArrayLen=255 ; 
Note: See TracChangeset for help on using the changeset viewer.