Changeset 1918


Ignore:
Timestamp:
07/16/20 17:18:01 (4 years ago)
Author:
ymipsl
Message:

Big update on on going work related to data distribution and transfer between clients and servers.

  • move all related file into distribution directorie
  • implement the concept of data "View"
  • implement the concept of "connector" which make the data transfer between 2 differents "Views"

YM

Location:
XIOS/dev/dev_ym/XIOS_COUPLING/src
Files:
44 added
18 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/array_new.hpp

    r1875 r1918  
    567567      virtual bool isEmpty(void) const { return !initialized; } 
    568568      virtual size_t size(void) const { return size(this->numElements()); } 
     569      virtual std::vector<T_numtype> getVector(void) { return vector<T_numtype>(this->dataFirst(),this->dataFirst()+this->numElements()) ;} 
    569570      static size_t size(sizeType numElements) { return (N_rank + 1) * sizeof(int) + sizeof(size_t) + numElements * sizeof(T_numtype); } 
    570571       

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/context_client.hpp

    r1853 r1918  
    6767      int getRemoteSize(void) {return serverSize;} 
    6868      int getServerSize(void) {return serverSize;} 
     69      MPI_Comm getIntraComm(void)  {return intraComm ;}  
     70      int getIntraCommSize(void) {return clientSize ;} 
     71      int getIntraCommRank(void) {return clientRank ;} 
    6972 
    7073      /*! set the associated server (dual chanel client/server) */       

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/filter/source_filter.cpp

    r1869 r1918  
    4343    else 
    4444    { 
    45       if (mask) 
    46         grid->maskField(data, packet->data); 
    47       else 
    48         grid->inputField(data, packet->data); 
     45      if (mask) grid->maskField(data, packet->data); 
     46      else grid->inputField(data, packet->data); 
    4947    } 
    5048    // Convert missing values to NaN 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/axis.cpp

    r1875 r1918  
    333333      this->checkData(); 
    334334      this->checkLabel(); 
     335      initializeLocalElement() ; 
     336      addFullView() ; 
     337      addWorkflowView() ; 
     338      addModelView() ; 
     339 
     340      checkAttributes_done_ = true ; 
     341   } 
     342   CATCH_DUMP_ATTR 
     343 
     344 
     345 
     346   void CAxis::initializeLocalElement(void) 
     347   { 
     348      // after checkAttribute index of size n 
     349      int rank = CContext::getCurrent()->getIntraCommRank() ; 
    335350       
    336       checkAttributes_done_ = true ; 
    337    } 
    338    CATCH_DUMP_ATTR 
     351      CArray<size_t,1> ind(n) ; 
     352      for (int i=0;i<n;i++) ind(i)=index(i) ; 
     353 
     354      localElement_ = new CLocalElement(rank, n_glo, ind) ; 
     355   } 
     356 
     357   void CAxis::addFullView(void) 
     358   { 
     359      CArray<int,1> index(n) ; 
     360      for(int i=0; i<n ; i++) index(i)=i ; 
     361      localElement_ -> addView(CElementView::FULL, index) ; 
     362   } 
     363 
     364   void CAxis::addWorkflowView(void) 
     365   { 
     366     // mask + data are included into data_index 
     367     int nk=data_index.numElements() ; 
     368     int nMask=0 ; 
     369     for(int k=0;k<nk;k++) if (data_index(k)>=0 && data_index(k)<n) nMask++ ; 
     370      
     371     CArray<int,1> index(nMask) ; 
     372     nMask=0 ; 
     373     for(int k=0;k<nk;k++)  
     374       if (data_index(k)>=0 && data_index(k)<n)  
     375       { 
     376         index(nMask) = data_index(k) ; 
     377         nMask++ ; 
     378       } 
     379     localElement_ -> addView(CElementView::WORKFLOW, index) ; 
     380   } 
     381 
     382   void CAxis::addModelView(void) 
     383   { 
     384     // information for model view is stored in data_index 
     385     localElement_->addView(CElementView::MODEL, data_index) ; 
     386   } 
     387 
     388   void CAxis::computeModelToWorkflowConnector(void) 
     389   {  
     390     CLocalView* srcView=getLocalView(CElementView::MODEL) ; 
     391     CLocalView* dstView=getLocalView(CElementView::WORKFLOW) ; 
     392     modelToWorkflowConnector_ = new CLocalConnector(srcView, dstView);  
     393     modelToWorkflowConnector_->computeConnector() ; 
     394   } 
    339395 
    340396   /*! 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/axis.hpp

    r1875 r1918  
    1616#include "transformation.hpp" 
    1717#include "transformation_enum.hpp" 
     18#include "element.hpp" 
     19#include "local_connector.hpp" 
    1820 
    1921namespace xios { 
    … …  
    222224         static bool dummyTransformationMapList_; 
    223225 
     226 
     227          
     228        private: 
     229         CLocalElement* localElement_ = nullptr ; 
     230         void initializeLocalElement(void) ; 
     231        public:  
     232         CLocalElement* getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; } 
     233         CLocalView* getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;} 
     234        private: 
     235         void addFullView(void) ; 
     236         void addWorkflowView(void) ; 
     237         void addModelView(void) ; 
     238 
     239        private: 
     240         CLocalConnector* modelToWorkflowConnector_ ; 
     241         void computeModelToWorkflowConnector(void)  ; 
     242        public: 
     243         CLocalConnector* getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;} 
     244 
     245 
    224246         DECLARE_REF_FUNC(Axis,axis) 
    225247   }; // class CAxis 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/domain.cpp

    r1879 r1918  
    1818#include "server_distribution_description.hpp" 
    1919#include "client_server_mapping_distributed.hpp" 
     20#include "local_connector.hpp" 
     21#include "grid_local_connector.hpp" 
     22#include "remote_connector.hpp" 
     23#include "gatherer_connector.hpp" 
     24#include "scatterer_connector.hpp" 
     25#include "grid_scatterer_connector.hpp" 
     26#include "grid_gatherer_connector.hpp" 
     27 
     28 
     29 
    2030 
    2131#include <algorithm> 
    … …  
    17341744      this->computeLocalMask() ; 
    17351745      this->completeLonLatClient(); 
     1746      this->initializeLocalElement() ; 
     1747      this->addFullView() ; 
     1748      this->addWorkflowView() ; 
     1749      this->addModelView() ; 
     1750      // testing ? 
     1751      CLocalView* local = localElement_->getView(CElementView::WORKFLOW) ; 
     1752      CLocalView* model = localElement_->getView(CElementView::MODEL) ; 
     1753 
     1754      CLocalConnector test1(model, local) ; 
     1755      test1.computeConnector() ; 
     1756      CLocalConnector test2(local, model) ; 
     1757      test2.computeConnector() ; 
     1758      CGridLocalConnector gridTest1(vector<CLocalConnector*>{&test1}) ; 
     1759      CGridLocalConnector gridTest2(vector<CLocalConnector*>{&test2}) ; 
     1760       
     1761       
     1762      CArray<int,1> out1 ; 
     1763      CArray<int,1> out2 ; 
     1764      test1.transfer(data_i_index,out1,-111) ; 
     1765      test2.transfer(out1,out2,-111) ; 
     1766       
     1767      out1 = 0 ; 
     1768      out2 = 0 ; 
     1769      gridTest1.transfer(data_i_index,out1,-111) ; 
     1770      gridTest2.transfer(out1, out2,-111) ; 
     1771       
    17361772      this->checkAttributes_done_ = true; 
    17371773   } 
    17381774   CATCH_DUMP_ATTR 
     1775 
     1776 
     1777   void CDomain::initializeLocalElement(void) 
     1778   { 
     1779      // after checkDomain i_index and j_index of size (ni*nj)  
     1780      int nij = ni*nj ; 
     1781      CArray<size_t, 1> ij_index(ni*nj) ; 
     1782      for(int ij=0; ij<nij ; ij++) ij_index(ij) = i_index(ij)+j_index(ij)*ni_glo ; 
     1783      int rank = CContext::getCurrent()->getIntraCommRank() ; 
     1784      localElement_ = new CLocalElement(rank, ni_glo*nj_glo, ij_index) ; 
     1785   } 
     1786 
     1787   void CDomain::addFullView(void) 
     1788   { 
     1789      CArray<int,1> index(ni*nj) ; 
     1790      int nij=ni*nj ; 
     1791      for(int ij=0; ij<nij ; ij++) index(ij)=ij ; 
     1792      localElement_ -> addView(CElementView::FULL, index) ; 
     1793   } 
     1794 
     1795   void CDomain::addWorkflowView(void) 
     1796   { 
     1797     // information for workflow view is stored in localMask 
     1798     int nij=ni*nj ; 
     1799     int nMask=0 ; 
     1800     for(int ij=0; ij<nij ; ij++) if (localMask(ij)) nMask++ ; 
     1801     CArray<int,1> index(nMask) ; 
     1802 
     1803     nMask=0 ; 
     1804     for(int ij=0; ij<nij ; ij++)  
     1805      if (localMask(ij)) 
     1806      { 
     1807        index(nMask)=ij ; 
     1808        nMask++ ; 
     1809      } 
     1810      localElement_ -> addView(CElementView::WORKFLOW, index) ; 
     1811   } 
     1812 
     1813   void CDomain::addModelView(void) 
     1814   { 
     1815     // information for model view is stored in data_i_index/data_j_index 
     1816     // very weird, do not mix data_i_index and data_i_begin => in future only keep data_i_index 
     1817     int dataSize = data_i_index.numElements() ; 
     1818     CArray<int,1> index(dataSize) ; 
     1819     int i,j ; 
     1820     for(int k=0;k<dataSize;k++) 
     1821     { 
     1822        i=data_i_index(k)+data_ibegin ; // bad 
     1823        j=data_j_index(k)+data_jbegin ; // bad 
     1824        if (i>=0 && i<ni && j>=0 && j<nj) index(k)=i+j*ni ; 
     1825        else index(k)=-1 ; 
     1826     } 
     1827     localElement_->addView(CElementView::MODEL, index) ; 
     1828   } 
     1829         
     1830   void CDomain::computeModelToWorkflowConnector(void) 
     1831   {  
     1832     CLocalView* srcView=getLocalView(CElementView::MODEL) ; 
     1833     CLocalView* dstView=getLocalView(CElementView::WORKFLOW) ; 
     1834     modelToWorkflowConnector_ = new CLocalConnector(srcView, dstView);  
     1835     modelToWorkflowConnector_->computeConnector() ; 
     1836   } 
     1837 
    17391838 
    17401839   //---------------------------------------------------------------- 
    … …  
    20992198    this->sendArea(client);     
    21002199    this->sendDataIndex(client); 
     2200 
     2201    // test new connector functionnality 
     2202    this->sendDomainDistribution(client) ; 
    21012203  } 
    21022204 
    … …  
    21292231    this->createAlias(domainId) ; 
    21302232  } 
     2233 
     2234 
     2235  void CDomain::sendDomainDistribution(CContextClient* client, const string& domainId) 
     2236  TRY 
     2237  { 
     2238    string serverDomainId = domainId.empty() ? this->getId() : domainId ; 
     2239    CContext* context = CContext::getCurrent(); 
     2240    int nbServer = client->serverSize; 
     2241    std::vector<int> nGlobDomain(2); 
     2242    nGlobDomain[0] = this->ni_glo; 
     2243    nGlobDomain[1] = this->nj_glo; 
     2244 
     2245    CServerDistributionDescription serverDescription(nGlobDomain, nbServer); 
     2246    int distributedPosition ; 
     2247    if (isUnstructed_) distributedPosition = 0 ; 
     2248    else distributedPosition = 1 ; 
     2249 
     2250    serverDescription.computeServerDistribution(false, distributedPosition); 
     2251     
     2252    std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin(); 
     2253    std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes(); 
     2254  
     2255    vector<unordered_map<size_t,vector<int>>> indexServerOnElement ; 
     2256    CArray<int,1> axisDomainOrder(1) ; axisDomainOrder(0)=2 ; 
     2257    auto zeroIndex=serverDescription.computeServerGlobalByElement(indexServerOnElement, context->getIntraCommRank(), context->getIntraCommSize(), 
     2258                                                                  axisDomainOrder,distributedPosition) ; 
     2259    // distribution is very bad => to redo 
     2260    // convert indexServerOnElement => map<int,CArray<size_t,1>> - need to be changed later 
     2261    map<int, vector<size_t>> vectGlobalIndex ; 
     2262    for(auto& indexRanks : indexServerOnElement[0]) 
     2263    { 
     2264      size_t index=indexRanks.first ; 
     2265      auto& ranks=indexRanks.second ; 
     2266      for(int rank : ranks) vectGlobalIndex[rank].push_back(index) ; 
     2267    } 
     2268    map<int, CArray<size_t,1>> globalIndex ; 
     2269    for(auto& vect : vectGlobalIndex ) globalIndex.emplace(vect.first, CArray<size_t,1>(vect.second.data(), shape(vect.second.size()))) ;  
     2270 
     2271    CDistributedElement remoteElement(ni_glo*nj_glo, globalIndex) ; 
     2272    remoteElement.addFullView() ; 
     2273 
     2274    CRemoteConnector remoteConnector(localElement_->getView(CElementView::FULL), remoteElement.getView(CElementView::FULL),context->getIntraComm()) ; 
     2275    remoteConnector.computeConnector() ; 
     2276    CDistributedElement scatteredElement(remoteElement.getGlobalSize(), remoteConnector.getDistributedGlobalIndex()) ; 
     2277    scatteredElement.addFullView() ; 
     2278    CScattererConnector scatterConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL), context->getIntraComm()) ; 
     2279    scatterConnector.computeConnector() ; 
     2280    CGridScattererConnector gridScatter({&scatterConnector}) ; 
     2281 
     2282    CEventClient event0(getType(), EVENT_ID_DOMAIN_DISTRIBUTION); 
     2283    CMessage message0 ; 
     2284    message0<<serverDomainId<<0 ;  
     2285    remoteElement.sendToServer(client,event0,message0) ; 
     2286 
     2287    CEventClient event1(getType(), EVENT_ID_DOMAIN_DISTRIBUTION); 
     2288    CMessage message1 ; 
     2289    message1<<serverDomainId<<1<<localElement_->getView(CElementView::FULL)->getGlobalSize() ;  
     2290    scatterConnector.transfer(localElement_->getView(CElementView::FULL)->getGlobalIndex(),client,event1,message1) ; 
     2291     
     2292    CEventClient event2(getType(), EVENT_ID_DOMAIN_DISTRIBUTION); 
     2293    CMessage message2 ; 
     2294    message2<<serverDomainId<<2 ;  
     2295//    scatterConnector.transfer(localElement_->getView(CElementView::FULL)->getGlobalIndex(),client,event2,message2) ; 
     2296    scatterConnector.transfer(localElement_->getView(CElementView::FULL)->getGlobalIndex(),client,event2,message2) ; 
     2297 
     2298/* 
     2299    localElement_->getView(CElementView::FULL)->sendRemoteElement(remoteConnector, client, event1, message1) ; 
     2300    CEventClient event2(getType(), EVENT_ID_DOMAIN_DISTRIBUTION); 
     2301    CMessage message2 ; 
     2302    message2<<serverDomainId<<2 ;  
     2303    remoteConnector.transferToServer(localElement_->getView(CElementView::FULL)->getGlobalIndex(),client,event2,message2) ; 
     2304*/ 
     2305 
     2306  } 
     2307  CATCH 
     2308   
     2309 
     2310  void CDomain::recvDomainDistribution(CEventServer& event) 
     2311  TRY 
     2312  { 
     2313    string domainId; 
     2314    int phasis ; 
     2315    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> domainId >> phasis ; 
     2316    get(domainId)->receivedDomainDistribution(event, phasis); 
     2317  } 
     2318  CATCH 
     2319 
     2320  void CDomain::receivedDomainDistribution(CEventServer& event, int phasis) 
     2321  TRY 
     2322  { 
     2323    CContext* context = CContext::getCurrent(); 
     2324    if (phasis==0) 
     2325    { 
     2326      localElement_ = new  CLocalElement(context->getIntraCommRank(),event) ; 
     2327      localElement_->addFullView() ; 
     2328    } 
     2329    else if (phasis==1) 
     2330    { 
     2331      CContext* context = CContext::getCurrent(); 
     2332      CDistributedElement* elementFrom = new  CDistributedElement(event) ; 
     2333      elementFrom->addFullView() ; 
     2334      gathererConnector_ = new CGathererConnector(elementFrom->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
     2335      gathererConnector_->computeConnector() ;  
     2336    } 
     2337    else if (phasis==2) 
     2338    { 
     2339      CArray<size_t,1> globalIndex ; 
     2340      //gathererConnector_->transfer(event,globalIndex) ; 
     2341      CGridGathererConnector gridGathererConnector({gathererConnector_}) ; 
     2342      gridGathererConnector.transfer(event, globalIndex) ; 
     2343    } 
     2344    else if (phasis==3) 
     2345    { 
     2346 
     2347    } 
     2348  } 
     2349  CATCH 
     2350 
     2351   
    21312352 
    21322353  /*! 
    … …  
    24822703          return true; 
    24832704          break; 
     2705        case EVENT_ID_DOMAIN_DISTRIBUTION: 
     2706          recvDomainDistribution(event); 
     2707          return true; 
     2708          break; 
    24842709        default: 
    24852710          ERROR("bool CDomain::dispatchEvent(CEventServer& event)", 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/domain.hpp

    r1875 r1918  
    1818#include "server_distribution_description.hpp" 
    1919#include "mesh.hpp" 
     20#include "element.hpp" 
     21#include "local_connector.hpp" 
     22#include "gatherer_connector.hpp" 
    2023 
    2124namespace xios { 
    … …  
    5053           EVENT_ID_INDEX, EVENT_ID_LON, EVENT_ID_LAT,  
    5154           EVENT_ID_AREA, 
    52            EVENT_ID_DATA_INDEX, EVENT_ID_SERVER_ATTRIBUT 
     55           EVENT_ID_DATA_INDEX, EVENT_ID_SERVER_ATTRIBUT, 
     56           EVENT_ID_DOMAIN_DISTRIBUTION 
    5357         } ; 
    5458 
    … …  
    216220       private: 
    217221 
     222         static void recvDomainDistribution(CEventServer& event) ; 
     223         void receivedDomainDistribution(CEventServer& event, int phasis) ; 
     224         
     225 
     226         void sendDomainDistribution(CContextClient* client, const string& domainId="") ; //for testing 
    218227         void sendAttributes(); // ym obsolete -> to be removed 
    219228         void sendIndex(CContextClient* client, const string& domainId=""); 
    … …  
    301310         static bool _dummyTransformationMapList; 
    302311 
     312  
     313       private: 
     314         CLocalElement* localElement_ = nullptr ; 
     315         void initializeLocalElement(void) ; 
     316        
     317       public:   
     318         CLocalElement* getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; } 
     319         CLocalView* getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;} 
     320        
     321       private:   
     322         void addFullView(void) ; 
     323         void addWorkflowView(void) ; 
     324         void addModelView(void) ; 
     325         
     326       private: 
     327         CLocalConnector* modelToWorkflowConnector_ ; 
     328         void computeModelToWorkflowConnector(void)  ; 
     329         CGathererConnector*  gathererConnector_ ; 
     330 
     331       public: 
     332         CLocalConnector* getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;} 
     333          
    303334         DECLARE_REF_FUNC(Domain,domain) 
    304335 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.cpp

    r1881 r1918  
    372372   CATCH 
    373373 
     374    
     375   CArray<bool,1>& CGrid::getMask(void) 
     376   { 
     377       
     378      if (mask_.isEmpty()) 
     379      {   
     380        if (!mask_0d.isEmpty()) mask_.reference(CArray<bool,1>(mask_0d.dataFirst(),shape(mask_0d.numElements()), neverDeleteData)) ; 
     381        if (!mask_1d.isEmpty()) mask_.reference(CArray<bool,1>(mask_1d.dataFirst(),shape(mask_1d.numElements()), neverDeleteData)) ; 
     382        if (!mask_2d.isEmpty()) mask_.reference(CArray<bool,1>(mask_2d.dataFirst(),shape(mask_2d.numElements()), neverDeleteData)) ; 
     383        if (!mask_3d.isEmpty()) mask_.reference(CArray<bool,1>(mask_3d.dataFirst(),shape(mask_3d.numElements()), neverDeleteData)) ; 
     384        if (!mask_4d.isEmpty()) mask_.reference(CArray<bool,1>(mask_4d.dataFirst(),shape(mask_4d.numElements()), neverDeleteData)) ; 
     385        if (!mask_5d.isEmpty()) mask_.reference(CArray<bool,1>(mask_5d.dataFirst(),shape(mask_5d.numElements()), neverDeleteData)) ; 
     386        if (!mask_6d.isEmpty()) mask_.reference(CArray<bool,1>(mask_6d.dataFirst(),shape(mask_6d.numElements()), neverDeleteData)) ; 
     387        if (!mask_7d.isEmpty()) mask_.reference(CArray<bool,1>(mask_7d.dataFirst(),shape(mask_7d.numElements()), neverDeleteData)) ; 
     388      } 
     389      return mask_ ; 
     390   } 
    374391   /* 
    375392     Create mask of grid from mask of its components 
    … …  
    30443061  CATCH_DUMP_ATTR 
    30453062 
     3063 
     3064  void CGrid::computeGridLocalElements() 
     3065  { 
     3066    std::vector<CDomain*> domainList = this->getDomains(); 
     3067    std::vector<CAxis*> axisList = this->getAxis(); 
     3068    auto domain=domainList.begin() ; 
     3069    auto axis=axisList.begin() ; 
     3070    vector<CLocalElement*> elements; 
     3071    for(auto order : order_) 
     3072    { 
     3073      if (order==2)  
     3074      { 
     3075        elements.push_back((*domain)->getLocalElement()); 
     3076        domain++ ; 
     3077      } 
     3078      else if (order==1) 
     3079      { 
     3080        elements.push_back((*axis)->getLocalElement()); 
     3081        axis++ ; 
     3082      } 
     3083      else if (order==0) 
     3084      {  
     3085      } 
     3086    } 
     3087    if (hasMask())  
     3088    { 
     3089      vector<bool> mask(getMask().getVector()) ; 
     3090      gridLocalElements_ = new CGridLocalElements(elements, mask) ;   
     3091    } 
     3092    else gridLocalElements_ = new CGridLocalElements(elements) ;   
     3093  } 
     3094 
     3095  void CGrid::computeModelToWorkflowConnector(void) 
     3096  { 
     3097    modelToWorkflowConnector_ = getGridLocalElements()->getConnector(CElementView::MODEL,CElementView::WORKFLOW) ; 
     3098  } 
    30463099} // namespace xios 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.hpp

    r1881 r1918  
    1616#include "utils.hpp" 
    1717#include "transformation_enum.hpp" 
     18#include "grid_local_connector.hpp" 
     19#include "grid_elements.hpp" 
    1820 
    1921namespace xios { 
    … …  
    255257         void modifyMask(const CArray<int,1>& indexToModify, bool valueToModify = false); 
    256258         void modifyMaskSize(const std::vector<int>& newDimensionSize, bool newValue = false); 
     259         
     260        /** get mask pointer stored in mask_1d, or mask_2d, or..., or mask_7d */ 
     261         CArray<bool,1> mask_ ; 
     262         CArray<bool,1>& getMask(void) ; 
    257263 
    258264         void computeGridGlobalDimension(const std::vector<CDomain*>& domains, 
    … …  
    289295                          const CArray<int,1>& axisDomainOrder, 
    290296                          bool createMask = false); 
     297 
    291298        template<int N> 
    292299        void modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify); 
    … …  
    500507/** List order of axis and domain in a grid, if there is a domain, it will take value 2, axis 1, scalar 0 */ 
    501508        std::vector<int> order_; 
     509 
     510      private:   
     511        CGridLocalElements* gridLocalElements_= nullptr ; 
     512        void computeGridLocalElements(void) ; 
     513      public: 
     514        CGridLocalElements* getGridLocalElements(void) { if (gridLocalElements_==nullptr) computeGridLocalElements() ; return gridLocalElements_ ;} 
     515 
     516      private: 
     517        CGridLocalConnector* modelToWorkflowConnector_ ; 
     518      public: 
     519        void computeModelToWorkflowConnector(void) ; 
     520        CGridLocalConnector* getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_;} 
    502521 
    503522   }; // class CGrid 
    … …  
    521540   CATCH 
    522541 
     542/* obsolete 
    523543   template <int n> 
    524544   void CGrid::maskField(const CArray<double,n>& field, CArray<double,1>& stored) 
    … …  
    534554      this->maskField_arr(field.dataFirst(), stored); 
    535555   } 
     556*/ 
     557   template <int n> 
     558   void CGrid::maskField(const CArray<double,n>& field, CArray<double,1>& stored) 
     559   { 
     560      auto connector = getModelToWorkflowConnector() ; 
     561 
     562      if (connector->getSrcSize() != field.numElements()) 
     563         ERROR("void CGrid::inputField(const  CArray<double,n>& field, CArray<double,1>& stored) const", 
     564                << "[ Awaiting data of size = " << this->getDataSize() << ", " 
     565                << "Received data size = "      << field.numElements() << " ] " 
     566                << "The data array does not have the right size! " 
     567                << "Grid = " << this->getId()) 
     568      const double nanValue = std::numeric_limits<double>::quiet_NaN(); 
     569      connector->transfer(field, stored, nanValue) ; 
     570   } 
     571 
     572 
    536573 
    537574   template <int n> 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/type/message.cpp

    r1158 r1918  
    99 
    1010   CMessage::CMessage(void) {} 
     11 
     12   CMessage::CMessage(const CMessage& msg)  
     13   { 
     14     for(auto type : msg.typeList) push(*type) ; 
     15   } 
     16 
    1117    
    1218   CMessage& CMessage::push(const CBaseType& type) 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/type/message.hpp

    r591 r1918  
    1717     
    1818    CMessage(void) ; 
     19    CMessage(const CMessage& Msg)  ; 
     20     
    1921    list<CBaseType*> typeList ; 
    2022    virtual bool fromBuffer(CBufferIn& buffer) const; 
Note: See TracChangeset for help on using the changeset viewer.