24 class CGridAttributes;
29 class CDistributionClient;
30 class CDistributionServer;
31 class CServerDistributionDescription;
32 class CClientServerMapping;
33 class CGridTransformation;
39 # include "grid_attribute.conf"
46 , public CGridAttributes
65 CGrid(
const CGrid& grid);
66 CGrid(
const CGrid*
const grid);
71 void checkEligibilityForCompressedOutput();
73 void solveDomainAxisRef(
bool areAttributesChecked);
75 void checkMaskIndex(
bool doCalculateIndex);
80 void addRelFileCompressed(
const StdString& filename);
83 bool isCompressible(
void)
const;
84 bool isWrittenCompressed(
const StdString& filename)
const;
91 StdSize getDataSize(
void)
const;
106 virtual ~CGrid(
void);
117 static CGrid* createGrid(
CDomain* domain);
119 static CGrid* createGrid(
const std::vector<CDomain*>& domains,
const std::vector<CAxis*>& axis,
121 static CGrid* createGrid(
StdString id,
const std::vector<CDomain*>& domains,
const std::vector<CAxis*>& axis,
123 static CGrid* createGrid(
const std::vector<CDomain*>& domains,
const std::vector<CAxis*>& axis,
124 const std::vector<CScalar*>& scalars,
const CArray<int,1>& axisDomainOrder);
125 static StdString generateId(
const std::vector<CDomain*>& domains,
const std::vector<CAxis*>& axis,
127 static StdString generateId(
const CGrid* gridSrc,
const CGrid* gridDest);
128 static CGrid* cloneGrid(
const StdString& idNewGrid, CGrid* gridSrc);
131 void computeIndexServer(
void);
132 void computeIndex(
void);
133 void computeIndexScalarGrid();
134 void computeWrittenIndex();
136 void solveDomainRef(
bool checkAtt);
137 void solveAxisRef(
bool checkAtt);
138 void solveScalarRef(
bool checkAtt);
139 void solveDomainAxisRefInheritance(
bool apply =
true);
140 void solveTransformations();
141 void solveDomainAxisBaseRef();
146 void sendAddDomain(
const std::string&
id=
"");
147 void sendAddAxis(
const std::string&
id=
"");
148 void sendAddScalar(
const std::string&
id=
"");
149 void sendAllDomains();
151 void sendAllScalars();
162 void recvIndex(vector<int> ranks, vector<CBufferIn*> buffers);
163 void sendIndex(
void);
164 void sendIndexScalarGrid();
168 void computeDomConServer();
169 std::map<int, int> getDomConServerSide();
170 std::map<int, StdSize> getAttributesBufferSize(
CContextClient* client,
bool bufferForWriting =
false);
171 std::map<int, StdSize> getDataBufferSize(
CContextClient* client,
const std::string&
id =
"",
bool bufferForWriting =
false);
172 std::vector<StdString> getDomainList();
173 std::vector<StdString> getAxisList();
174 std::vector<StdString> getScalarList();
175 std::vector<CDomain*> getDomains();
176 std::vector<CAxis*> getAxis();
177 std::vector<CScalar*> getScalars();
178 CDomain* getDomain(
int domainIndex);
179 CAxis* getAxis(
int axisIndex);
180 CScalar* getScalar(
int scalarIndex);
181 std::vector<int> getAxisOrder();
182 std::vector<int> getGlobalDimension();
183 bool isScalarGrid()
const;
185 bool doGridHaveDataToWrite();
187 size_t getWrittenDataSize()
const;
188 int getNumberWrittenIndexes()
const;
189 int getTotalNumberWrittenIndexes()
const;
190 int getOffsetWrittenIndexes()
const;
196 void transformGrid(CGrid* transformGridSrc);
197 void completeGrid(CGrid* transformGridSrc = 0);
198 void doAutoDistribution(CGrid* transformGridSrc);
199 bool isTransformed();
200 void setTransformed();
203 void addTransGridSource(CGrid* gridSrc);
204 std::map<CGrid*, std::pair<bool,StdString> >& getTransGridSource();
206 size_t getGlobalWrittenSize(
void) ;
249 bool hasMask(
void)
const;
250 void checkMask(
void);
251 void createMask(
void);
252 void modifyMask(
const CArray<int,1>& indexToModify,
bool valueToModify =
false);
253 void modifyMaskSize(
const std::vector<int>& newDimensionSize,
bool newValue =
false);
255 void computeGridGlobalDimension(
const std::vector<CDomain*>& domains,
256 const std::vector<CAxis*>& axis,
257 const std::vector<CScalar*>& scalars,
266 bool createMask =
false);
271 void modifyGridMaskSize(
CArray<bool,N>& gridMask,
const std::vector<int>& eachDimSize,
bool newValue);
274 void restoreField_arr(
const CArray<double, 1>& stored,
double*
const data)
const;
275 void uncompressField_arr(
const double*
const data,
CArray<double, 1>& outData)
const;
278 void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
279 void setVirtualAxisGroup(CAxisGroup* newVAxisGroup);
280 void setVirtualScalarGroup(CScalarGroup* newVScalarGroup);
282 void setDomainList(
const std::vector<CDomain*> domains = std::vector<CDomain*>());
283 void setAxisList(
const std::vector<CAxis*> axis = std::vector<CAxis*>());
284 void setScalarList(
const std::vector<CScalar*> scalars = std::vector<CScalar*>());
286 CDomainGroup* getVirtualDomainGroup()
const;
287 CAxisGroup* getVirtualAxisGroup()
const;
288 CScalarGroup* getVirtualScalarGroup()
const;
290 void checkAttributesAfterTransformation();
291 void setTransformationAlgorithms();
292 void computeIndexByElement(
const std::vector<std::unordered_map<
size_t,std::vector<int> > >& indexServerOnElement,
295 int computeGridGlobalDimension(std::vector<int>& globalDim,
296 const std::vector<CDomain*> domains,
297 const std::vector<CAxis*> axis,
298 const std::vector<CScalar*> scalars,
300 int getDistributedDimension();
302 void computeClientIndex();
303 void computeConnectedClients();
304 void computeClientIndexScalarGrid();
305 void computeConnectedClientsScalarGrid();
357 std::map<CGrid*, std::pair<bool,StdString> >
gridSrc_;
379 if (this->getDataSize() != field.numElements())
380 ERROR(
"void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const",
381 <<
"[ Awaiting data of size = " << this->getDataSize() <<
", "
382 <<
"Received data size = " << field.numElements() <<
" ] "
383 <<
"The data array does not have the right size! "
384 <<
"Grid = " << this->getId())
386 this->storeField_arr(field.dataFirst(), stored);
395 ERROR(
"void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const",
396 <<
"[ Awaiting data of size = " << this->
getDataSize() <<
", "
397 <<
"Received data size = " << field.numElements() <<
" ] "
398 <<
"The data array does not have the right size! "
399 <<
"Grid = " << this->
getId())
409 if (this->getDataSize() != field.numElements())
410 ERROR(
"void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const",
411 <<
"[ Size of the data = " << this->getDataSize() <<
", "
412 <<
"Output data size = " << field.numElements() <<
" ] "
413 <<
"The ouput array does not have the right size! "
414 <<
"Grid = " << this->getId())
416 this->restoreField_arr(stored, field.dataFirst());
430 uncompressField_arr(data.dataFirst(), outData);
443 int numElement = axisDomainOrder.numElements();
444 int dim = domainMasks.size() * 2 + axisMasks.size();
445 std::vector<CDomain*> domainP = this->getDomains();
446 std::vector<CAxis*> axisP = this->getAxis();
448 std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim);
449 std::vector<int> currentIndex(dim);
450 int idxDomain = 0, idxAxis = 0;
454 if (2 == axisDomainOrder(i)) {
455 eachDimSize[indexMap[i]] = domainP[idxDomain]->ni;
456 eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj;
457 idx += 2; ++idxDomain;
459 else if (1 == axisDomainOrder(i)) {
461 eachDimSize[indexMap[i]] = axisP[idxAxis]->n;
467 if (!gridMask.isEmpty() && !createMask)
469 for (
int i = 0; i < dim; ++i)
471 if (gridMask.extent(i) != eachDimSize[i])
472 ERROR(
"CGrid::checkMask(void)",
473 <<
"The mask has one dimension whose size is different from the one of the local grid." << std::endl
474 <<
"Local size of dimension " << i <<
" is " << eachDimSize[i] <<
"." << std::endl
475 <<
"Mask size for dimension " << i <<
" is " << gridMask.extent(i) <<
"." << std::endl
476 <<
"Grid = " << this->getId())
484 int ssize = gridMask.numElements();
488 for (
int i = 0; i < dim-1; ++i)
490 if (idxLoop[i] == eachDimSize[i])
498 idxDomain = idxAxis = 0;
499 bool maskValue =
true;
502 if (2 == axisDomainOrder(i))
504 int idxTmp = idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]];
505 if (idxTmp < (*domainMasks[idxDomain]).numElements())
506 maskValue = maskValue && (*domainMasks[idxDomain])(idxTmp);
511 else if (1 == axisDomainOrder(i))
513 int idxTmp = idxLoop[indexMap[i]];
514 if (idxTmp < (*axisMasks[idxAxis]).numElements())
515 maskValue = maskValue && (*axisMasks[idxAxis])(idxTmp);
523 int maskIndex = idxLoop[0];
525 for (
int k = 1; k < dim; ++k)
527 mulDim *= eachDimSize[k-1];
528 maskIndex += idxLoop[k]*mulDim;
530 *(gridMask.dataFirst()+maskIndex) &= maskValue;
540 const std::vector<int>& eachDimSize,
544 if (N != eachDimSize.size())
569 int num = indexToModify.numElements();
570 for (
int idx = 0; idx < num; ++idx)
572 *(gridMask.dataFirst()+indexToModify(idx)) = valueToModify;
588 #endif // __XIOS_CGrid__
std::set< std::string > relFilesCompressed
void modifyGridMask(CArray< bool, N > &gridMask, const CArray< int, 1 > &indexToModify, bool valueToModify)
int totalNumberWrittenIndexes_
map< int, CArray< int, 1 > > storeIndex_fromSrv
#define END_DECLARE_ATTRIBUTE_MAP(type)
CGridAttributes RelAttributes
CArray< size_t, 1 > localIndexToWriteOnServer
CScalarGroup * vScalarGroup_
std::map< int, std::map< int, int > > nbSenders
std::map< int, std::vector< int > > connectedServerRank_
void outputField(const CArray< double, 1 > &stored, CArray< double, n > &field) const
map< int, CArray< size_t, 1 > > compressedOutIndexFromClient
std::map< CContextClient *, map< int, CArray< int, 1 > > > storeIndex_toSrv
void uncompressField(const CArray< double, n > &data, CArray< double, 1 > &outData) const
std::set< CContextClient * > clientsSet
std::list< CContextClient * > clients
std::map< int, size_t > connectedDataSizeRead_
std::map< CContextClient *, std::map< int, int > > nbReadSenders
std::vector< int > connectedServerRankRead_
void maskField_arr(const double *const data, CArray< double, 1 > &stored) const
const StdString & getId(void) const
Accesseurs ///.
std::map< int, std::map< int, size_t > > connectedDataSize_
CDistributionServer * serverDistribution_
This class computes index of data which are sent to server as well as index of data on server side...
bool isCompressible_
True if and only if the data defined on the grid can be outputted in a compressed way...
map< int, CArray< size_t, 1 > > outGlobalIndexFromClient
#define BEGIN_DECLARE_ATTRIBUTE_MAP(type)
StdSize getDataSize(void) const
bool hasDomainAxisBaseRef_
std::unordered_map< int, std::vector< size_t > > GlobalIndexMap
CATCH CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CScalar *scalarDestination, CScalar *scalarSource, CReduceScalarToScalar *algo ERROR)("CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CScalar* scalarDestination, CScalar* scalarSource, CReduceScalarToScalar* algo)",<< "Operation must be defined."<< "Scalar source "<< scalarSource->getId()<< std::endl<< "Scalar destination "<< scalarDestination->getId())
std::vector< int > order_
A context can be both on client and on server side.
////////////////////// Déclarations ////////////////////// ///
std::vector< int > axisPositionInGrid_
void checkGridMask(CArray< bool, N > &gridMask, const std::vector< CArray< bool, 1 > * > &domainMasks, const std::vector< CArray< bool, 1 > * > &axisMasks, const CArray< int, 1 > &axisDomainOrder, bool createMask=false)
////////////////////// Déclarations ////////////////////// ///
map< int, CArray< size_t, 1 > > outLocalIndexStoreOnClient
CArray< size_t, 1 > localIndexToWriteOnClient
void modifyGridMaskSize(CArray< bool, N > &gridMask, const std::vector< int > &eachDimSize, bool newValue)
CObjectTemplate< CGrid > SuperClass
typedef ///
map< int, CArray< size_t, 1 > > outIndexFromClient
std::vector< std::string > scalarList_
CGridTransformation * transformations_
CClientServerMapping * clientServerMap_
Mapping between index client and server.
CDistributionClient * clientDistribution_
bool computedWrittenIndex_
void maskField(const CArray< double, n > &field, CArray< double, 1 > &stored) const
CArray< bool, 1 > storeMask_client
CArray< int, 1 > storeIndex_client
std::map< CGrid *, std::pair< bool, StdString > > gridSrc_
enum xios::_node_type ENodeType
////////////////////// Définitions ////////////////////// ///
CArray< size_t, 1 > indexFromClients
CDomainGroup * vDomainGroup_
This class bases on the knowledge of distribution on client side (decided by users) to calculate the ...
Index distribution on server side.
void inputField(const CArray< double, n > &field, CArray< double, 1 > &stored) const
Entrees-sorties de champs.
CGridAttributes SuperClassAttribute
The class, for now, plays a role of computing local index for writing data on server.
std::map< int, CClientServerMapping::GlobalIndexMap > globalIndexOnServer_