Changeset 1642 for XIOS/dev/branch_openmp/src/transformation

XIOS/dev/branch_openmp/src/transformation/Functions/reduction.cpp

-                      r1339
+                      r1642
 CReductionAlgorithm::CallBackMap* CReductionAlgorithm::reductionCreationCallBacks_ = 0;
+std::map<StdString,EReductionType> *CReductionAlgorithm::ReductionOperations_ptr = 0;
+std::map<StdString,EReductionType> CReductionAlgorithm::ReductionOperations = std::map<StdString,EReductionType>();
 bool CReductionAlgorithm::initReductionOperation(std::map<StdString,EReductionType>& m)
+{
 …
+}
+bool CReductionAlgorithm::initReductionOperation()
+{
+  CReductionAlgorithm::ReductionOperations_ptr = new std::map<StdString,EReductionType>();
+  // So so stupid way to intialize operation but it works ...
+  (*CReductionAlgorithm::ReductionOperations_ptr)["sum"] = TRANS_REDUCE_SUM;
+  CSumReductionAlgorithm::registerTrans();
+  (*CReductionAlgorithm::ReductionOperations_ptr)["min"] = TRANS_REDUCE_MIN;
+  CMinReductionAlgorithm::registerTrans();
+  (*CReductionAlgorithm::ReductionOperations_ptr)["max"] = TRANS_REDUCE_MAX;
+  CMaxReductionAlgorithm::registerTrans();
+  (*CReductionAlgorithm::ReductionOperations_ptr)["extract"] = TRANS_REDUCE_EXTRACT;
+  CExtractReductionAlgorithm::registerTrans();
+  (*CReductionAlgorithm::ReductionOperations_ptr)["average"] = TRANS_REDUCE_AVERAGE;
+  CAverageReductionAlgorithm::registerTrans();
+}
+//bool CReductionAlgorithm::_dummyInit = CReductionAlgorithm::initReductionOperation(CReductionAlgorithm::ReductionOperations);
+//bool CReductionAlgorithm::_dummyInit = CReductionAlgorithm::initReductionOperation();
+bool CReductionAlgorithm::_dummyInit = CReductionAlgorithm::initReductionOperation(CReductionAlgorithm::ReductionOperations);
 CReductionAlgorithm* CReductionAlgorithm::createOperation(EReductionType reduceType)

XIOS/dev/branch_openmp/src/transformation/Functions/reduction.hpp

-                      r1545
+                      r1642
+{
 public:
   static std::map<StdString,EReductionType> *ReductionOperations_ptr;
+  #pragma omp threadprivate(ReductionOperations_ptr)
+  static std::map<StdString,EReductionType> ReductionOperations;
 public:
   CReductionAlgorithm() {}
 …
   typedef std::map<EReductionType, CreateOperationCallBack> CallBackMap;
   static CallBackMap* reductionCreationCallBacks_;
-  #pragma omp threadprivate(reductionCreationCallBacks_)
   static bool registerOperation(EReductionType reduceType, CreateOperationCallBack createFn);
 …
 protected:
   static bool initReductionOperation(std::map<StdString,EReductionType>& m);
-  static bool initReductionOperation();
   static bool _dummyInit;
-  #pragma omp threadprivate(_dummyInit)
 };

XIOS/dev/branch_openmp/src/transformation/algo_types.hpp

-                      r1460
+                      r1642
 #include "axis_algorithm_zoom.hpp"
 #include "axis_algorithm_interpolate.hpp"
+#include "axis_algorithm_extract.hpp"
 #include "axis_algorithm_reduce_domain.hpp"
 #include "axis_algorithm_reduce_axis.hpp"
 …
 #include "scalar_algorithm_reduce_scalar.hpp"
 #include "domain_algorithm_reorder.hpp"
+#include "domain_algorithm_extract.hpp"

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_duplicate_scalar.cpp

r1460	r1642
21	21	std::map<int, int>& elementPositionInGridDst2AxisPosition,
22	22	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	23	TRY
23	24	{
24	25	std::vector<CAxis*> axisListDestP = gridDst->getAxis();
…	…
31	32	return (new CAxisAlgorithmDuplicateScalar(axisListDestP[axisDstIndex], scalarListSrcP[scalarSrcIndex], duplicateScalar));
32	33	}
	34	CATCH
33	35
34	36	bool CAxisAlgorithmDuplicateScalar::registerTrans()
	37	TRY
35	38	{
36	39	CGridTransformationFactory<CAxis>::registerTransformation(TRANS_DUPLICATE_SCALAR_TO_AXIS, create);
37	40	}
	41	CATCH
38	42
39	43
…	…
50	54
51	55	void CAxisAlgorithmDuplicateScalar::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
	56	TRY
52	57	{
53	58	this->transformationMapping_.resize(1);
…	…
69	74	}
70	75	}
71
	76	CATCH
72	77	}

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_extract_domain.cpp

r1545	r1642
13	13	#include "grid.hpp"
14	14	#include "grid_transformation_factory_impl.hpp"
	15	#include "reduction.hpp"
15	16
16	17	namespace xios {
…	…
24	25	std::map<int, int>& elementPositionInGridDst2AxisPosition,
25	26	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	27	TRY
26	28	{
27	29	std::vector<CAxis*> axisListDestP = gridDst->getAxis();
…	…
34	36	return (new CAxisAlgorithmExtractDomain(axisListDestP[axisDstIndex], domainListSrcP[domainSrcIndex], extractDomain));
35	37	}
	38	CATCH
36	39
37	40	//bool CAxisAlgorithmExtractDomain::_dummyRegistered = CAxisAlgorithmExtractDomain::registerTrans();
38	41	bool CAxisAlgorithmExtractDomain::registerTrans()
	42	TRY
39	43	{
40	44	CGridTransformationFactory<CAxis>::registerTransformation(TRANS_EXTRACT_DOMAIN_TO_AXIS, create);
41	45	}
	46	CATCH
42	47
43	48
44	49	CAxisAlgorithmExtractDomain::CAxisAlgorithmExtractDomain(CAxis* axisDestination, CDomain* domainSource, CExtractDomainToAxis* algo)
45	50	: CAxisAlgorithmTransformation(axisDestination, domainSource), pos_(-1), reduction_(0)
	51	TRY
46	52	{
47	53	algo->checkValid(axisDestination, domainSource);
…	…
61	67
62	68	pos_ = algo->position;
63		if(CReductionAlgorithm::ReductionOperations_ptr == 0)
64		{
65		CReductionAlgorithm::initReductionOperation();
66		}
67		reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations_ptr->at(op));
	69	reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]);
68	70	}
	71	CATCH
69	72
70	73	void CAxisAlgorithmExtractDomain::apply(const std::vector<std::pair<int,double> >& localIndex,
…	…
73	76	std::vector<bool>& flagInitial,
74	77	bool ignoreMissingValue, bool firstPass)
	78	TRY
75	79	{
76	80	reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass);
77	81	}
	82	CATCH
78	83
79	84	CAxisAlgorithmExtractDomain::~CAxisAlgorithmExtractDomain()
	85	TRY
80	86	{
81	87	if (0 != reduction_) delete reduction_;
82	88	}
	89	CATCH
83	90
84	91	void CAxisAlgorithmExtractDomain::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
	92	TRY
85	93	{
86	94	this->transformationMapping_.resize(1);
…	…
120	128	{}
121	129	}
122
	130	CATCH
123	131	}

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_extract_domain.hpp

-                      r1339
+                      r1642
 #include "transformation.hpp"
-#include "reduction.hpp"
 namespace xios {
 …
   Extract a domain to an axis
 */
 class CAxisAlgorithmExtractDomain : public CAxisAlgorithmTransformation, public CReductionAlgorithm
+class CAxisAlgorithmExtractDomain : public CAxisAlgorithmTransformation
+{
 public:

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_interpolate.cpp

r1460	r1642
29	29	std::map<int, int>& elementPositionInGridDst2AxisPosition,
30	30	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	31	TRY
31	32	{
32	33	std::vector<CAxis*> axisListDestP = gridDst->getAxis();
…	…
39	40	return (new CAxisAlgorithmInterpolate(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], interpolateAxis));
40	41	}
	42	CATCH
41	43
42	44	bool CAxisAlgorithmInterpolate::registerTrans()
	45	TRY
43	46	{
44	47	CGridTransformationFactory<CAxis>::registerTransformation(TRANS_INTERPOLATE_AXIS, create);
45	48	}
46
	49	CATCH
47	50
48	51	CAxisAlgorithmInterpolate::CAxisAlgorithmInterpolate(CAxis* axisDestination, CAxis* axisSource, CInterpolateAxis* interpAxis)
49	52	: CAxisAlgorithmTransformation(axisDestination, axisSource), coordinate_(), transPosition_()
	53	TRY
50	54	{
51	55	interpAxis->checkValid(axisSource);
…	…
58	62	}
59	63	}
	64	CATCH
60	65
61	66	/*!
…	…
63	68	*/
64	69	void CAxisAlgorithmInterpolate::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
	70	TRY
65	71	{
66	72	CTimer::get("CAxisAlgorithmInterpolate::computeIndexSourceMapping_").resume() ;
…	…
88	94	CTimer::get("CAxisAlgorithmInterpolate::computeIndexSourceMapping_").suspend() ;
89	95	}
	96	CATCH
90	97
91	98	/*!
…	…
98	105	const std::vector<int>& indexVec,
99	106	int transPos)
	107	TRY
100	108	{
101	109	std::vector<double>::const_iterator itb = axisValue.begin(), ite = axisValue.end();
…	…
162	170	computeWeightedValueAndMapping(interpolatingIndexValues, transPos);
163	171	}
	172	CATCH
164	173
165	174	/*!
…	…
168	177	*/
169	178	void CAxisAlgorithmInterpolate::computeWeightedValueAndMapping(const std::map<int, std::vector<std::pair<int,double> > >& interpolatingIndexValues, int transPos)
	179	TRY
170	180	{
171	181	TransformationIndexMap& transMap = this->transformationMapping_[transPos];
…	…
205	215
206	216	}
	217	CATCH
207	218
208	219	/*!
…	…
213	224	void CAxisAlgorithmInterpolate::retrieveAllAxisValue(const CArray<double,1>& axisValue, const CArray<bool,1>& axisMask,
214	225	std::vector<double>& recvBuff, std::vector<int>& indexVec)
	226	TRY
215	227	{
216	228	CContext* context = CContext::getCurrent();
…	…
260	272
261	273	int* recvCount=new int[nbClient];
262		~~MPI_Allgather(&numValue,1,MPI_INT,recvCount,1,MPI~~_INT,client->intraComm);
	274	ep_lib::MPI_Allgather(&numValue,1,EP_INT,recvCount,1,EP_INT,client->intraComm);
263	275
264	276	int* displ=new int[nbClient];
…	…
267	279
268	280	// Each client have enough global info of axis
269		~~MPI_Allgatherv(sendIndexBuff,numValue,MPI_INT,recvIndexBuff,recvCount,displ,MPI~~_INT,client->intraComm);
270		~~MPI_Allgatherv(sendValueBuff,numValue,MPI_DOUBLE,&(recvBuff[0]),recvCount,displ,MPI~~_DOUBLE,client->intraComm);
	281	ep_lib::MPI_Allgatherv(sendIndexBuff,numValue,EP_INT,recvIndexBuff,recvCount,displ,EP_INT,client->intraComm);
	282	ep_lib::MPI_Allgatherv(sendValueBuff,numValue,EP_DOUBLE,&(recvBuff[0]),recvCount,displ,EP_DOUBLE,client->intraComm);
271	283
272	284	for (int idx = 0; idx < srcSize; ++idx)
…	…
282	294	}
283	295	}
	296	CATCH
284	297
285	298	/*!
…	…
289	302	void CAxisAlgorithmInterpolate::fillInAxisValue(std::vector<CArray<double,1> >& vecAxisValue,
290	303	const std::vector<CArray<double,1>* >& dataAuxInputs)
	304	TRY
291	305	{
292	306	if (coordinate_.empty())
…	…
377	391	}
378	392	}
379
380		}
	393	CATCH
	394
	395	}

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_inverse.cpp

-                      r1545
+                      r1642
 #include "inverse_axis.hpp"
 #include "client_client_dht_template.hpp"
-using namespace ep_lib;
 namespace xios {
 …
                                                                std::map<int, int>& elementPositionInGridDst2AxisPosition,
                                                                std::map<int, int>& elementPositionInGridDst2DomainPosition)
+TRY
+{
   std::vector<CAxis*> axisListDestP = gridDst->getAxis();
 …
   return (new CAxisAlgorithmInverse(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], inverseAxis));
+}
+CATCH
 bool CAxisAlgorithmInverse::registerTrans()
+TRY
+{
   CGridTransformationFactory<CAxis>::registerTransformation(TRANS_INVERSE_AXIS, create);
+}
+CATCH
 CAxisAlgorithmInverse::CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource, CInverseAxis* inverseAxis)
  : CAxisAlgorithmTransformation(axisDestination, axisSource)
+TRY
+{
   if (axisDestination->n_glo.getValue() != axisSource->n_glo.getValue())
 …
+  }
+}
+CATCH
 void CAxisAlgorithmInverse::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
+TRY
+{
   this->transformationMapping_.resize(1);
 …
+  }
+}
+CATCH
 /*!
 …
 */
 void CAxisAlgorithmInverse::updateAxisValue()
+TRY
+{
   CContext* context = CContext::getCurrent();
 …
     sendRankSizeMap[itIndex->first] = sendSize;
+  }
   MPI_Allgather(&connectedClient,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm);
+  ep_lib::MPI_Allgather(&connectedClient,1,EP_INT,recvCount,1,EP_INT,client->intraComm);
   displ[0]=0 ;
 …
   int* recvRankBuff=new int[recvSize];
   int* recvSizeBuff=new int[recvSize];
   MPI_Allgatherv(sendRankBuff,connectedClient,MPI_INT,recvRankBuff,recvCount,displ,MPI_INT,client->intraComm);
   MPI_Allgatherv(sendSizeBuff,connectedClient,MPI_INT,recvSizeBuff,recvCount,displ,MPI_INT,client->intraComm);
+  ep_lib::MPI_Allgatherv(sendRankBuff,connectedClient,EP_INT,recvRankBuff,recvCount,displ,EP_INT,client->intraComm);
+  ep_lib::MPI_Allgatherv(sendSizeBuff,connectedClient,EP_INT,recvSizeBuff,recvCount,displ,EP_INT,client->intraComm);
   for (int i = 0; i < nbClient; ++i)
+  {
 …
   // Sending global index of grid source to corresponding process as well as the corresponding mask
   std::vector<MPI_Request> requests;
   std::vector<MPI_Status> status;
+  std::vector<ep_lib::MPI_Request> requests;
+  std::vector<ep_lib::MPI_Status> status;
   std::unordered_map<int, unsigned long* > recvGlobalIndexSrc;
   std::unordered_map<int, double* > sendValueToDest;
 …
     sendValueToDest[recvRank] = new double [recvSize];
     requests.push_back(MPI_Request());
     MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, MPI_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back());
+    requests.push_back(ep_lib::MPI_Request());
+    ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back());
+  }
 …
     // Send global index source and mask
     requests.push_back(MPI_Request());
     MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, MPI_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back());
+    requests.push_back(ep_lib::MPI_Request());
+    ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back());
+  }
   status.resize(requests.size());
   MPI_Waitall(requests.size(), &requests[0], &status[0]);
   std::vector<MPI_Request>().swap(requests);
   std::vector<MPI_Status>().swap(status);
+  ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]);
+  std::vector<ep_lib::MPI_Request>().swap(requests);
+  std::vector<ep_lib::MPI_Status>().swap(status);
   // Okie, on destination side, we will wait for information of masked index of source
 …
     int recvSize = itSend->second;
     requests.push_back(MPI_Request());
     MPI_Irecv(recvValueFromSrc[recvRank], recvSize, MPI_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
+    requests.push_back(ep_lib::MPI_Request());
+    ep_lib::MPI_Irecv(recvValueFromSrc[recvRank], recvSize, EP_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
+  }
 …
+    }
     // Okie, now inform the destination which source index are masked
     requests.push_back(MPI_Request());
     MPI_Isend(sendValueToDest[recvRank], recvSize, MPI_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
+    requests.push_back(ep_lib::MPI_Request());
+    ep_lib::MPI_Isend(sendValueToDest[recvRank], recvSize, EP_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
+  }
   status.resize(requests.size());
   MPI_Waitall(requests.size(), &requests[0], &status[0]);
+  ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]);
 …
     delete [] itLong->second;
+}
+}
+CATCH
+}

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_reduce_axis.cpp

r1545	r1642
12	12	#include "grid.hpp"
13	13	#include "grid_transformation_factory_impl.hpp"
	14	#include "reduction.hpp"
14	15
15	16	namespace xios {
…	…
23	24	std::map<int, int>& elementPositionInGridDst2AxisPosition,
24	25	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	26	TRY
25	27	{
26	28	std::vector<CAxis*> axisListDestP = gridDst->getAxis();
…	…
33	35	return (new CAxisAlgorithmReduceAxis(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], reduceAxis));
34	36	}
	37	CATCH
35	38
36	39	bool CAxisAlgorithmReduceAxis::registerTrans()
	40	TRY
37	41	{
38	42	CGridTransformationFactory<CAxis>::registerTransformation(TRANS_REDUCE_AXIS_TO_AXIS, create);
39	43	}
	44	CATCH
40	45
41	46
42	47	CAxisAlgorithmReduceAxis::CAxisAlgorithmReduceAxis(CAxis* axisDestination, CAxis* axisSource, CReduceAxisToAxis* algo)
43	48	: CAxisAlgorithmTransformation(axisDestination, axisSource), reduction_(0)
	49	TRY
44	50	{
45	51	eliminateRedondantSrc_= false ;
…	…
67	73
68	74	}
69		~~if(CReductionAlgorithm::ReductionOperations_ptr == 0)~~
70		{
71		~~CReductionAlgorithm::initReductionOperation();~~
72		}
73	75
74		reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations~~_ptr->at(op)~~);
	76	reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]);
75	77	}
	78	CATCH
76	79
77	80	void CAxisAlgorithmReduceAxis::apply(const std::vector<std::pair<int,double> >& localIndex,
…	…
80	83	std::vector<bool>& flagInitial,
81	84	bool ignoreMissingValue, bool firstPass)
	85	TRY
82	86	{
83	87	reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass);
84	88	}
	89	CATCH
85	90
86	91	void CAxisAlgorithmReduceAxis::updateData(CArray<double,1>& dataOut)
	92	TRY
87	93	{
88	94	reduction_->updateData(dataOut);
89	95	}
	96	CATCH
90	97
91	98	CAxisAlgorithmReduceAxis::~CAxisAlgorithmReduceAxis()
	99	TRY
92	100	{
93	101	if (0 != reduction_) delete reduction_;
94	102	}
	103	CATCH
95	104
96	105	void CAxisAlgorithmReduceAxis::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
	106	TRY
97	107	{
98	108	this->transformationMapping_.resize(1);
…	…
112	122	}
113	123	}
	124	CATCH
114	125
115	126	}

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_reduce_axis.hpp

-                      r1460
+                      r1642
 #include "axis_algorithm_transformation.hpp"
 #include "transformation.hpp"
-#include "reduction.hpp"
 namespace xios {
 …
   Reduce a axis to an axis
 */
 class CAxisAlgorithmReduceAxis : public CAxisAlgorithmTransformation, public CReductionAlgorithm
+class CAxisAlgorithmReduceAxis : public CAxisAlgorithmTransformation
+{
 public:

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_reduce_domain.cpp

r1545	r1642
13	13	#include "grid.hpp"
14	14	#include "grid_transformation_factory_impl.hpp"
15
	15	#include "reduction.hpp"
16	16
17	17	namespace xios {
…	…
25	25	std::map<int, int>& elementPositionInGridDst2AxisPosition,
26	26	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	27	TRY
27	28	{
28	29	std::vector<CAxis*> axisListDestP = gridDst->getAxis();
…	…
35	36	return (new CAxisAlgorithmReduceDomain(axisListDestP[axisDstIndex], domainListSrcP[domainSrcIndex], reduceDomain));
36	37	}
	38	CATCH
37	39
38	40	bool CAxisAlgorithmReduceDomain::registerTrans()
	41	TRY
39	42	{
40	43	CGridTransformationFactory<CAxis>::registerTransformation(TRANS_REDUCE_DOMAIN_TO_AXIS, create);
41	44	}
	45	CATCH
42	46
43	47
44	48	CAxisAlgorithmReduceDomain::CAxisAlgorithmReduceDomain(CAxis* axisDestination, CDomain* domainSource, CReduceDomainToAxis* algo)
45	49	: CAxisAlgorithmTransformation(axisDestination, domainSource), reduction_(0)
	50	TRY
46	51	{
47	52	algo->checkValid(axisDestination, domainSource);
…	…
70	75
71	76	dir_ = (CReduceDomainToAxis::direction_attr::iDir == algo->direction) ? iDir : jDir;
72		if(CReductionAlgorithm::ReductionOperations_ptr == 0)
73		{
74		CReductionAlgorithm::initReductionOperation();
75		}
76		reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations_ptr->at(op));
	77	reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]);
77	78	local = algo->local ;
78	79	}
	80	CATCH
79	81
80	82	void CAxisAlgorithmReduceDomain::apply(const std::vector<std::pair<int,double> >& localIndex,
…	…
83	85	std::vector<bool>& flagInitial,
84	86	bool ignoreMissingValue, bool firstPass)
	87	TRY
85	88	{
86	89	reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass);
87	90	}
	91	CATCH
88	92
89	93	void CAxisAlgorithmReduceDomain::updateData(CArray<double,1>& dataOut)
	94	TRY
90	95	{
91	96	reduction_->updateData(dataOut);
92	97	}
	98	CATCH
93	99
94	100	CAxisAlgorithmReduceDomain::~CAxisAlgorithmReduceDomain()
	101	TRY
95	102	{
96	103	if (0 != reduction_) delete reduction_;
97	104	}
	105	CATCH
98	106
99	107	void CAxisAlgorithmReduceDomain::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
	108	TRY
100	109	{
101	110	this->transformationMapping_.resize(1);
…	…
178	187	{}
179	188	}
	189	CATCH
180	190
181	191	}

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_reduce_domain.hpp

-                      r1460
+                      r1642
 #include "axis_algorithm_transformation.hpp"
 #include "transformation.hpp"
-#include "reduction.hpp"
 namespace xios {
 …
   Reduce a domain to an axis
 */
 class CAxisAlgorithmReduceDomain : public CAxisAlgorithmTransformation, public CReductionAlgorithm
+class CAxisAlgorithmReduceDomain : public CAxisAlgorithmTransformation
+{
 public:
 …
     jDir = 2
   };
   ReduceDirection dir_;
   bool local ;

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_temporal_splitting.cpp

r1460	r1642
21	21	std::map<int, int>& elementPositionInGridDst2AxisPosition,
22	22	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	23	TRY
23	24	{
24	25	std::vector<CAxis*> axisListDestP = gridDst->getAxis();
…	…
31	32	return (new CAxisAlgorithmTemporalSplitting(axisListDestP[axisDstIndex], scalarListSrcP[scalarSrcIndex], temporalSplitting));
32	33	}
	34	CATCH
33	35
34	36	bool CAxisAlgorithmTemporalSplitting::registerTrans()
	37	TRY
35	38	{
36	39	CGridTransformationFactory<CAxis>::registerTransformation(TRANS_TEMPORAL_SPLITTING, create);
37	40	}
38
	41	CATCH
39	42
40	43	CAxisAlgorithmTemporalSplitting::CAxisAlgorithmTemporalSplitting(CAxis* axisDestination, CScalar* scalarSource, CTemporalSplitting* algo)
…	…
50	53
51	54	void CAxisAlgorithmTemporalSplitting::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
	55	TRY
52	56	{
53	57	this->transformationMapping_.resize(1);
…	…
72	76	}
73	77	}
	78	CATCH
74	79
75	80	}

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_transformation.cpp

r1460	r1642
20	20	CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource)
21	21	: CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(axisSource), domainSrc_(0),scalarSrc_(0)
	22	TRY
22	23	{
23	24	axisDestGlobalSize_ = axisDestination->n_glo.getValue();
…	…
28	29	if ((axisDestination->mask)(idx)) axisDestGlobalIndex_.push_back(ibeginDest+idx);
29	30	}
	31	CATCH
30	32
31	33	CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CDomain* domainSource)
32	34	: CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(0), domainSrc_(domainSource),scalarSrc_(0)
	35	TRY
33	36	{
34	37	axisDestGlobalSize_ = axisDestination->n_glo.getValue();
…	…
39	42	if ((axisDestination->mask)(idx)) axisDestGlobalIndex_.push_back(ibeginDest+idx);
40	43	}
	44	CATCH
41	45
42	46	CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CScalar* scalarSource)
43	47	: CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(0), domainSrc_(0), scalarSrc_(scalarSource)
	48	TRY
44	49	{
45	50	axisDestGlobalSize_ = axisDestination->n_glo.getValue();
…	…
50	55	if ((axisDestination->mask)(idx)) axisDestGlobalIndex_.push_back(ibeginDest+idx);
51	56	}
	57	CATCH
	58
52	59	CAxisAlgorithmTransformation::~CAxisAlgorithmTransformation()
53	60	{
…	…
66	73	int elementType,
67	74	CClientClientDHTInt::Index2VectorInfoTypeMap& globalAxisIndexOnProc)
	75	TRY
68	76	{
69	77	CContext* context = CContext::getCurrent();
…	…
124	132	globalAxisIndexOnProc = dhtIndexProcRank.getInfoIndexMap();
125	133	}
	134	CATCH
126	135
127	136	}

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_zoom.cpp

-                      r1460
+                      r1642
 /*!
    \file axis_algorithm_zoom.cpp
+   \author Ha NGUYEN
+   \since 03 June 2015
+   \date 12 June 2015
+   \brief Algorithm for zooming on an axis.
+   \brief Algorithm for zooming an axis.
  */
 #include "axis_algorithm_zoom.hpp"
 …
                                                            std::map<int, int>& elementPositionInGridDst2AxisPosition,
                                                            std::map<int, int>& elementPositionInGridDst2DomainPosition)
+TRY
+{
   std::vector<CAxis*> axisListDestP = gridDst->getAxis();
 …
   return (new CAxisAlgorithmZoom(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], zoomAxis));
+}
+CATCH
 bool CAxisAlgorithmZoom::registerTrans()
+TRY
+{
   CGridTransformationFactory<CAxis>::registerTransformation(TRANS_ZOOM_AXIS, create);
+}
+CATCH
 CAxisAlgorithmZoom::CAxisAlgorithmZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis)
 : CAxisAlgorithmTransformation(axisDestination, axisSource)
+TRY
+{
   zoomAxis->checkValid(axisSource);
   zoomBegin_ = zoomAxis->begin.getValue();
   zoomSize_  = zoomAxis->n.getValue();
   zoomEnd_   = zoomBegin_ + zoomSize_ - 1;
+  zoomN_  = zoomAxis->n.getValue();
+  zoomEnd_   = zoomBegin_ + zoomN_ - 1;
   if (zoomSize_ > axisSource->n_glo.getValue())
+  if (zoomN_ > axisSource->n_glo.getValue())
+  {
     ERROR("CAxisAlgorithmZoom::CAxisAlgorithmZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis)",
            << "Zoom size is greater than global size of axis source"
            << "Global size of axis source " <<axisSource->getId() << " is " << axisSource->n_glo.getValue()  << std::endl
            << "Zoom size is " << zoomSize_ );
+           << "Zoom size is greater than global size of source axis"
+           << "Global size of source axis " <<axisSource->getId() << " is " << axisSource->n_glo.getValue()  << std::endl
+           << "Zoom size is " << zoomN_ );
+  }
+  if (!zoomAxis->index.isEmpty())
+  int idxSrc, nDest = 0, beginDestLoc, beginDestGlo = 0 ;
+  int indGloDest, indGloSrc, iSrc;
+  for (int i = 0; i < axisSrc_->n.getValue(); i++)
+  {
+    int sz = zoomAxis->index.numElements();
+    zoomIndex_.resize(sz);
+    for (int i = 0; i < sz; ++i)
+      zoomIndex_[i] = zoomAxis->index(i);
+    idxSrc = axisSrc_->index(i);
+    if ((idxSrc >= zoomBegin_) && (idxSrc <= zoomEnd_))
+    {
+      if (nDest == 0) beginDestLoc = i;
+      ++nDest;
+    }
+  }
+  beginDestGlo = beginDestLoc + axisSrc_->begin - zoomBegin_;
+  axisDest_->n_glo.setValue(zoomN_);
+  axisDest_->n.setValue(nDest);
+  axisDest_->begin.setValue(beginDestGlo);
+  axisDest_->index.resize(nDest);
+    std::sort(zoomIndex_.begin(), zoomIndex_.end());
+  axisDest_->data_n.setValue(nDest);
+  axisDest_->data_begin.setValue(0);
+  axisDest_->data_index.resize(nDest);
+  axisDest_->mask.resize(nDest);
+  if (axisSrc_->hasValue) axisDest_->value.resize(nDest);
+  if (axisSrc_->hasLabel) axisDest_->label.resize(nDest);
+  if (axisSrc_->hasBounds) axisDest_->bounds.resize(2,nDest);
+  this->transformationMapping_.resize(1);
+  this->transformationWeight_.resize(1);
+  TransformationIndexMap& transMap = this->transformationMapping_[0];
+  TransformationWeightMap& transWeight = this->transformationWeight_[0];
+  for (int iDest = 0; iDest < nDest; iDest++)
+  {
+    iSrc = iDest + beginDestLoc;
+    axisDest_->index(iDest) = iDest + beginDestGlo;
+    axisDest_->data_index(iDest) = axisSrc_->data_index(iSrc) - beginDestLoc;
+    axisDest_->mask(iDest) = axisSrc_->mask(iSrc);
+    if (axisSrc_->hasValue)
+      axisDest_->value(iDest) = axisSrc_->value(iSrc);
+    if (axisSrc_->hasLabel)
+      axisDest_->label(iDest) = axisSrc_->label(iSrc);
+    if (axisSrc_->hasBounds)
+    {
+      axisDest_->bounds(0,iDest) = axisSrc_->bounds(0,iSrc);
+      axisDest_->bounds(1,iDest) = axisSrc_->bounds(1,iSrc);
+    }
+    indGloDest = axisDest_->index(iDest);
+    indGloSrc = axisSrc_->index(iSrc);
+    transMap[indGloDest].push_back(indGloSrc);
+    transWeight[indGloDest].push_back(1.0);
+  }
+}
+CATCH
 /*!
   Compute the index mapping between axis on grid source and one on grid destination
+  Compute the index mapping between domain on grid source and one on grid destination
 */
 void CAxisAlgorithmZoom::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
+{
-  // We use all index of source and destination to calculate the mapping index of zoom.
-  // The server who receives the "zoomed" fields will decide whether it will forward these fields or write "real zoomed" fields into file
-  // That means servers need to change to cover this problem.
-  StdSize niSource = axisSrc_->n.getValue();
-  StdSize ibeginSource = axisSrc_->begin.getValue();
-  StdSize iendSource = ibeginSource + niSource - 1;
-  StdSize ibegin = std::max(ibeginSource, zoomBegin_);
-  StdSize iend = std::min(iendSource, zoomEnd_);
-  StdSize ni = iend + 1 - ibegin;
-  if (iend < ibegin) ni = 0;
-  this->transformationMapping_.resize(1);
-  this->transformationWeight_.resize(1);
-  TransformationIndexMap& transMap = this->transformationMapping_[0];
-  TransformationWeightMap& transWeight = this->transformationWeight_[0];
-  if (!zoomIndex_.empty())
+  {
-    std::vector<int>::iterator itZoomBegin, itZoomEnd;
-    itZoomBegin = std::lower_bound(zoomIndex_.begin(), zoomIndex_.end(), ibeginSource);
-    itZoomEnd   = std::upper_bound(zoomIndex_.begin(), zoomIndex_.end(), iendSource);
-    for (; itZoomBegin != itZoomEnd; ++itZoomBegin)
+    {
-      transMap[*itZoomBegin].push_back(*itZoomBegin);
-      transWeight[*itZoomBegin].push_back(1.0);
+    }
+  }
-  else
+  {
-    for (StdSize idx = 0; idx < ni; ++idx)
+    {
-      transMap[ibegin+idx].push_back(ibegin+idx);
-      transWeight[ibegin+idx].push_back(1.0);
+    }
+  }
-  updateZoom();
-  // updateAxisDestinationMask();
+}
-/*!
-  After a zoom on axis, it should be certain that (global) zoom begin and (global) zoom size are updated
-*/
-void CAxisAlgorithmZoom::updateZoom()
+{
-  axisDest_->global_zoom_begin = zoomBegin_;
-  axisDest_->global_zoom_n  = zoomSize_;
-  if (!zoomIndex_.empty())
+  {
-    axisDest_->global_zoom_index.resize(zoomIndex_.size());
-    std::copy(zoomIndex_.begin(), zoomIndex_.end(), axisDest_->global_zoom_index.begin());
+  }
+}
-/*!
-  Update mask on axis
-  Because only zoomed region on axis is not masked, the remaining must be masked to make sure
-correct index be extracted
-*/
-// void CAxisAlgorithmZoom::updateAxisDestinationMask()
-// {
-//   StdSize niMask = axisDest_->mask.numElements();
-//   StdSize iBeginMask = axisDest_->begin.getValue();
-//   StdSize globalIndexMask = 0;
-//   TransformationIndexMap& transMap = this->transformationMapping_[0];
-//   TransformationIndexMap::const_iterator ite = (transMap).end();
-//   for (StdSize idx = 0; idx < niMask; ++idx)
-//   {
-//     globalIndexMask = iBeginMask + idx;
-//     if (transMap.find(globalIndexMask) == ite)
-//       (axisDest_->mask)(idx) = false;
-//   }
-// }
+}

XIOS/dev/branch_openmp/src/transformation/axis_algorithm_zoom.hpp

-                      r1460
+                      r1642
 /*!
    \file axis_algorithm_zoom.hpp
+   \author Ha NGUYEN
+   \since 03 June 2015
+   \date 12 June 2015
+   \brief Algorithm for zooming on an axis.
+   \brief Algorithm for zooming an axis.
  */
 #ifndef __XIOS_AXIS_ALGORITHM_ZOOM_HPP__
 …
   Implementing zoom on axis
   A zoomed region can be considered as region that isn't masked.
   Only this zoomed region is extracted to write on Netcdf.
+  Only this zoomed region is zoomed to write on Netcdf.
 */
 class CAxisAlgorithmZoom : public CAxisAlgorithmTransformation
 …
 private:
-  // void updateAxisDestinationMask();
-  void updateZoom();
 private:
 …
   //! Global zoom size on axis
   StdSize zoomSize_;
+  StdSize zoomN_;
   std::vector<int> zoomIndex_;

XIOS/dev/branch_openmp/src/transformation/domain_algorithm_compute_connectivity.cpp

r978	r1642
24	24	std::map<int, int>& elementPositionInGridDst2AxisPosition,
25	25	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	26	TRY
26	27	{
27	28	std::vector<CDomain*> domainListDestP = gridDst->getDomains();
…	…
34	35	return (new CDomainAlgorithmComputeConnectivity(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], compute_connectivityDomain));
35	36	}
	37	CATCH
36	38
37	39	bool CDomainAlgorithmComputeConnectivity::registerTrans()
	40	TRY
38	41	{
39	42	CGridTransformationFactory<CDomain>::registerTransformation(TRANS_COMPUTE_CONNECTIVITY_DOMAIN, create);
40	43	}
	44	CATCH
41	45
42	46	CDomainAlgorithmComputeConnectivity::CDomainAlgorithmComputeConnectivity(CDomain* domainDestination, CDomain* domainSource,
43	47	CComputeConnectivityDomain* compute_connectivityDomain)
44	48	: CDomainAlgorithmTransformation(domainDestination, domainSource)
	49	TRY
45	50	{
46	51	this->type_ = (ELEMENT_NO_MODIFICATION_WITHOUT_DATA);
…	…
64	69	computeLocalConnectivity(type, domainDestination, nbNeighborMax, nbNeighbor, localNeighbors);
65	70	}
	71	CATCH
66	72
67	73	/*!
…	…
78	84	CArray<int,1>& nbConnectivity,
79	85	CArray<int,2>& localConnectivity)
	86	TRY
80	87	{
81	88
…	…
93	100	if (nbConnectivityMax < nbConnectivity(idx)) nbConnectivityMax = nbConnectivity(idx);
94	101	}
95
96
	102	CATCH
97	103
98	104	/*!

XIOS/dev/branch_openmp/src/transformation/domain_algorithm_expand.cpp

r1460	r1642
26	26	std::map<int, int>& elementPositionInGridDst2AxisPosition,
27	27	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	28	TRY
28	29	{
29	30	std::vector<CDomain*> domainListDestP = gridDst->getDomains();
…	…
36	37	return (new CDomainAlgorithmExpand(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], expandDomain));
37	38	}
	39	CATCH
38	40
39	41	bool CDomainAlgorithmExpand::registerTrans()
	42	TRY
40	43	{
41	44	CGridTransformationFactory<CDomain>::registerTransformation(TRANS_EXPAND_DOMAIN, create);
42	45	}
	46	CATCH
43	47
44	48	CDomainAlgorithmExpand::CDomainAlgorithmExpand(CDomain* domainDestination,
…	…
47	51	: CDomainAlgorithmTransformation(domainDestination, domainSource),
48	52	isXPeriodic_(false), isYPeriodic_(false)
	53	TRY
49	54	{
50	55	if (domainDestination == domainSource)
…	…
77	82	}
78	83	}
	84	CATCH
79	85
80	86	/*!
…	…
85	91	void CDomainAlgorithmExpand::expandDomainEdgeConnectivity(CDomain* domainDestination,
86	92	CDomain* domainSource)
	93	TRY
87	94	{
88	95	CContext* context = CContext::getCurrent();
…	…
104	111	}
105	112	}
	113	CATCH
106	114
107	115	/*!
…	…
112	120	void CDomainAlgorithmExpand::expandDomainNodeConnectivity(CDomain* domainDestination,
113	121	CDomain* domainSource)
	122	TRY
114	123	{
115	124	CContext* context = CContext::getCurrent();
…	…
131	140	}
132	141	}
	142	CATCH
133	143
134	144	/*!
…	…
142	152	CDomain* domainSource,
143	153	CArray<int,2>& neighborsDomainSrc)
	154	TRY
144	155	{
145	156	int index, globalIndex, idx;
…	…
161	172	else domainDestination->domain_ref.setValue(domainDstRef);
162	173
	174
163	175	// Here are attributes of source need tranfering
164	176	int niGloSrc = domainSource->ni_glo;
…	…
227	239	domainDestination->ni.setValue(niDst);
228	240	domainDestination->nj.setValue(njDst);
229		~~domainDestination->global_zoom_ni.setValue(domainSource->global_zoom_ni+2);~~
230		~~domainDestination->global_zoom_nj.setValue(domainSource->global_zoom_nj+2);~~
231	241
232	242	CArray<bool,1>& mask_1d_dst = domainDestination->domainMask;
…	…
456	466	domainDestination->computeLocalMask() ;
457	467	}
	468	CATCH
458	469
459	470	/*!
…	…
467	478	CDomain* domainSource,
468	479	CArray<int,2>& neighborsDomainSrc)
	480	TRY
469	481	{
470	482
…	…
670	682	domainDestination->computeLocalMask() ;
671	683	}
672
	684	CATCH
673	685
674	686	/*!

XIOS/dev/branch_openmp/src/transformation/domain_algorithm_generate_rectilinear.cpp

r1064	r1642
20	20	CGenerateRectilinearDomain* genRectDomain)
21	21	: CDomainAlgorithmTransformation(domainDestination, domainSource), nbDomainDistributedPart_(0)
	22	TRY
22	23	{
23	24	type_ = ELEMENT_GENERATION;
…	…
30	31	fillInAttributesDomainDestination();
31	32	}
	33	CATCH
32	34
33	35	/*!
…	…
43	45	*/
44	46	void CDomainAlgorithmGenerateRectilinear::computeDistributionGridSource(CGrid* gridSrc)
	47	TRY
45	48	{
46	49	CContext* context = CContext::getCurrent();
…	…
67	70	StdSize hashValue = hashFunc.hashVec(globalAxisIndex);
68	71	std::vector<StdSize> recvBuff(client->clientSize);
69		~~MPI_Gather(&hashValue, 1, MPI~~_UNSIGNED_LONG,
70		&recvBuff[0], 1, ~~MPI~~_UNSIGNED_LONG,
	72	ep_lib::MPI_Gather(&hashValue, 1, EP_UNSIGNED_LONG,
	73	&recvBuff[0], 1, EP_UNSIGNED_LONG,
71	74	0,
72	75	client->intraComm);
…	…
84	87	}
85	88
86		~~MPI_Bcast(&nbLocalAxis[0], nbAxis, MPI~~_INT,
	89	ep_lib::MPI_Bcast(&nbLocalAxis[0], nbAxis, EP_INT,
87	90	0, client->intraComm);
88	91	}
…	…
94	97	}
95	98	}
	99	CATCH
96	100
97	101	/*!
…	…
99	103	*/
100	104	void CDomainAlgorithmGenerateRectilinear::computeDistributionGridDestination(CGrid* gridDest)
	105	TRY
101	106	{
102	107	// For now, just suppose that the grid contains only one domain
…	…
121	126
122	127	}
	128	CATCH
123	129
124	130	/*!
…	…
126	132	*/
127	133	void CDomainAlgorithmGenerateRectilinear::fillInAttributesDomainDestination()
	134	TRY
128	135	{
129	136	if (!domainDest_->distributionAttributesHaveValue())
…	…
131	138	domainDest_->fillInLonLat();
132	139	}
133
	140	CATCH
134	141	}

XIOS/dev/branch_openmp/src/transformation/domain_algorithm_interpolate.cpp

-                      r1555
+                      r1642
 #include "interpolate_domain.hpp"
 #include "grid.hpp"
-using namespace ep_lib;
 namespace xios {
 …
                                                                      std::map<int, int>& elementPositionInGridDst2AxisPosition,
                                                                      std::map<int, int>& elementPositionInGridDst2DomainPosition)
+TRY
+{
   std::vector<CDomain*> domainListDestP = gridDst->getDomains();
 …
   return (new CDomainAlgorithmInterpolate(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], interpolateDomain));
+}
+CATCH
 bool CDomainAlgorithmInterpolate::registerTrans()
+TRY
+{
   CGridTransformationFactory<CDomain>::registerTransformation(TRANS_INTERPOLATE_DOMAIN, create);
+}
+CATCH
 CDomainAlgorithmInterpolate::CDomainAlgorithmInterpolate(CDomain* domainDestination, CDomain* domainSource, CInterpolateDomain* interpDomain)
 : CDomainAlgorithmTransformation(domainDestination, domainSource), interpDomain_(interpDomain), writeToFile_(false), readFromFile_(false)
+TRY
+{
   CContext* context = CContext::getCurrent();
 …
+}
+CATCH
 /*!
 …
 */
 void CDomainAlgorithmInterpolate::computeRemap()
+TRY
+{
   using namespace sphereRemap;
 …
   CArray<double,2> boundsLonSrcUnmasked(nVertexSrc,nSrcLocalUnmasked);
   CArray<double,2> boundsLatSrcUnmasked(nVertexSrc,nSrcLocalUnmasked);
+  CArray<double,1> areaSrcUnmasked(nSrcLocalUnmasked);
   long int * globalSrcUnmasked = new long int [nSrcLocalUnmasked];
   nSrcLocalUnmasked=0 ;
+  bool hasSrcArea=domainSrc_->hasArea && !domainSrc_->radius.isEmpty() && !interpDomain_->use_area.isEmpty() && interpDomain_->use_area==true  ;
+  double srcAreaFactor ;
+  if (hasSrcArea) srcAreaFactor=1./(domainSrc_->radius*domainSrc_->radius) ;
   for (int idx=0 ; idx < nSrcLocal; idx++)
+  {
 …
         boundsLatSrcUnmasked(n,nSrcLocalUnmasked) = boundsLatSrc(n,idx) ;
+      }
+      if (hasSrcArea) areaSrcUnmasked(nSrcLocalUnmasked) = domainSrc_->areavalue(idx)*srcAreaFactor ;
       globalSrcUnmasked[nSrcLocalUnmasked]=globalSrc[idx] ;
       ++nSrcLocalUnmasked ;
+    }
+  }
   int nDstLocalUnmasked = 0 ;
 …
   CArray<double,2> boundsLonDestUnmasked(nVertexDest,nDstLocalUnmasked);
   CArray<double,2> boundsLatDestUnmasked(nVertexDest,nDstLocalUnmasked);
+  CArray<double,1>   areaDstUnmasked(nDstLocalUnmasked);
   long int * globalDstUnmasked = new long int [nDstLocalUnmasked];
   nDstLocalUnmasked=0 ;
+  bool hasDstArea=domainDest_->hasArea && !domainDest_->radius.isEmpty() && !interpDomain_->use_area.isEmpty() && interpDomain_->use_area==true ;
+  double dstAreaFactor ;
+  if (hasDstArea) dstAreaFactor=1./(domainDest_->radius*domainDest_->radius) ;
   for (int idx=0 ; idx < nDstLocal; idx++)
+  {
 …
         boundsLatDestUnmasked(n,nDstLocalUnmasked) = boundsLatDest(n,idx) ;
+      }
+      if (hasDstArea) areaDstUnmasked(nDstLocalUnmasked) = domainDest_->areavalue(idx)*dstAreaFactor ;
       globalDstUnmasked[nDstLocalUnmasked]=globalDst[idx] ;
       ++nDstLocalUnmasked ;
 …
+  }
+  mapper.setSourceMesh(boundsLonSrcUnmasked.dataFirst(), boundsLatSrcUnmasked.dataFirst(), nVertexSrc, nSrcLocalUnmasked, &srcPole[0], globalSrcUnmasked);
+  mapper.setTargetMesh(boundsLonDestUnmasked.dataFirst(), boundsLatDestUnmasked.dataFirst(), nVertexDest, nDstLocalUnmasked, &dstPole[0], globalDstUnmasked);
+  double* ptAreaSrcUnmasked = NULL ;
+  if (hasSrcArea) ptAreaSrcUnmasked=areaSrcUnmasked.dataFirst() ;
+  double* ptAreaDstUnmasked = NULL ;
+  if (hasDstArea) ptAreaDstUnmasked=areaDstUnmasked.dataFirst() ;
+  mapper.setSourceMesh(boundsLonSrcUnmasked.dataFirst(), boundsLatSrcUnmasked.dataFirst(), ptAreaSrcUnmasked, nVertexSrc, nSrcLocalUnmasked, &srcPole[0], globalSrcUnmasked);
+  mapper.setTargetMesh(boundsLonDestUnmasked.dataFirst(), boundsLatDestUnmasked.dataFirst(), ptAreaDstUnmasked, nVertexDest, nDstLocalUnmasked, &dstPole[0], globalDstUnmasked);
   std::vector<double> timings = mapper.computeWeights(orderInterp,renormalize,quantity);
 …
+}
+CATCH
 void CDomainAlgorithmInterpolate::processPole(std::map<int,std::vector<std::pair<int,double> > >& interMapValuePole,
                                               int nbGlobalPointOnPole)
+TRY
+{
   CContext* context = CContext::getCurrent();
   CContextClient* client=context->client;
+  ep_lib::MPI_Comm poleComme = MPI_COMM_NULL;
+  ep_lib::MPI_Comm poleComme(EP_COMM_NULL);
+  #ifdef _usingMPI
+  MPI_Comm_split(client->intraComm, interMapValuePole.empty() ? MPI_UNDEFINED : 1, 0, &poleComme);
+  #elif _usingEP
   ep_lib::MPI_Comm_split(client->intraComm, interMapValuePole.empty() ? 0 : 1, 0, &poleComme);
+  if (poleComme!=MPI_COMM_NULL)
+  #endif
+  if (EP_COMM_NULL != poleComme)
+  {
     int nbClientPole;
 …
     std::vector<int> recvCount(nbClientPole,0);
     std::vector<int> displ(nbClientPole,0);
+    ep_lib::MPI_Allgather(&nbWeight,1,MPI_INT,&recvCount[0],1,MPI_INT,poleComme) ;
+    ep_lib::MPI_Allgather(&nbWeight,1,EP_INT,&recvCount[0],1,EP_INT,poleComme) ;
     displ[0]=0;
     for(int n=1;n<nbClientPole;++n) displ[n]=displ[n-1]+recvCount[n-1] ;
 …
     // Gather all index and weight for pole
     ep_lib::MPI_Allgatherv(&sendSourceIndexBuff[0],nbWeight,MPI_INT,&recvSourceIndexBuff[0],&recvCount[0],&displ[0],MPI_INT,poleComme);
     ep_lib::MPI_Allgatherv(&sendSourceWeightBuff[0],nbWeight,MPI_DOUBLE,&recvSourceWeightBuff[0],&recvCount[0],&displ[0],MPI_DOUBLE,poleComme);
+    ep_lib::MPI_Allgatherv(&sendSourceIndexBuff[0],nbWeight,EP_INT,&recvSourceIndexBuff[0],&recvCount[0],&displ[0],EP_INT,poleComme);
+    ep_lib::MPI_Allgatherv(&sendSourceWeightBuff[0],nbWeight,EP_DOUBLE,&recvSourceWeightBuff[0],&recvCount[0],&displ[0],EP_DOUBLE,poleComme);
     std::map<int,double> recvTemp;
 …
+}
+CATCH
 /*!
 …
 */
 void CDomainAlgorithmInterpolate::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
+TRY
+{
   if (readFromFile_)
 …
+  }
+}
+CATCH
 void CDomainAlgorithmInterpolate::writeRemapInfo(std::map<int,std::vector<std::pair<int,double> > >& interpMapValue)
+TRY
+{
   writeInterpolationInfo(fileToReadWrite_, interpMapValue);
+}
+CATCH
 void CDomainAlgorithmInterpolate::readRemapInfo()
+TRY
+{
   std::map<int,std::vector<std::pair<int,double> > > interpMapValue;
 …
   exchangeRemapInfo(interpMapValue);
+}
+CATCH
 void CDomainAlgorithmInterpolate::convertRemapInfo(std::map<int,std::vector<std::pair<int,double> > >& interpMapValue)
+TRY
+{
   CContext* context = CContext::getCurrent();
 …
+  }
+}
+CATCH
 /*!
 …
 */
 void CDomainAlgorithmInterpolate::exchangeRemapInfo(std::map<int,std::vector<std::pair<int,double> > >& interpMapValue)
+TRY
+{
   CContext* context = CContext::getCurrent();
 …
   ep_lib::MPI_Allreduce(sendBuff, recvBuff, nbClient, MPI_INT, MPI_SUM, client->intraComm);
+  ep_lib::MPI_Allreduce(sendBuff, recvBuff, nbClient, EP_INT, EP_SUM, client->intraComm);
   int* sendIndexDestBuff = new int [sendBuffSize];
 …
   double* sendWeightBuff = new double [sendBuffSize];
   std::vector<ep_lib::MPI_Request> sendRequest(3*globalIndexInterpSendToClient.size());
+  std::vector<ep_lib::MPI_Request> sendRequest;
   int sendOffSet = 0, l = 0;
-  int position = 0;
   for (itMap = itbMap; itMap != iteMap; ++itMap)
+  {
 …
+    }
+    sendRequest.push_back(ep_lib::MPI_Request());
     ep_lib::MPI_Isend(sendIndexDestBuff + sendOffSet,
              k,
              MPI_INT,
+             EP_INT,
              itMap->first,
              MPI_DOMAIN_INTERPOLATION_DEST_INDEX,
              client->intraComm,
+             &sendRequest[position++]);
+             &sendRequest.back());
+    sendRequest.push_back(ep_lib::MPI_Request());
     ep_lib::MPI_Isend(sendIndexSrcBuff + sendOffSet,
              k,
              MPI_INT,
+             EP_INT,
              itMap->first,
              MPI_DOMAIN_INTERPOLATION_SRC_INDEX,
              client->intraComm,
+             &sendRequest[position++]);
+             &sendRequest.back());
+    sendRequest.push_back(ep_lib::MPI_Request());
     ep_lib::MPI_Isend(sendWeightBuff + sendOffSet,
              k,
              MPI_DOUBLE,
+             EP_DOUBLE,
              itMap->first,
              MPI_DOMAIN_INTERPOLATION_WEIGHT,
              client->intraComm,
              &sendRequest[position++]);
+             &sendRequest.back());
     sendOffSet += k;
+  }
 …
+  {
     ep_lib::MPI_Status recvStatus;
+    #ifdef _usingMPI
+    MPI_Recv((recvIndexDestBuff + receivedSize),
+             recvBuffSize,
+             EP_INT,
+             MPI_ANY_SOURCE,
+             MPI_DOMAIN_INTERPOLATION_DEST_INDEX,
+             client->intraComm,
+             &recvStatus);
+    #elif _usingEP
     ep_lib::MPI_Recv((recvIndexDestBuff + receivedSize),
              recvBuffSize,
              MPI_INT,
+             EP_INT,
              -2,
              MPI_DOMAIN_INTERPOLATION_DEST_INDEX,
              client->intraComm,
              &recvStatus);
+    #endif
     int countBuff = 0;
     ep_lib::MPI_Get_count(&recvStatus, MPI_INT, &countBuff);
+    ep_lib::MPI_Get_count(&recvStatus, EP_INT, &countBuff);
     #ifdef _usingMPI
     clientSrcRank = recvStatus.MPI_SOURCE;
 …
     ep_lib::MPI_Recv((recvIndexSrcBuff + receivedSize),
              recvBuffSize,
              MPI_INT,
+             EP_INT,
              clientSrcRank,
              MPI_DOMAIN_INTERPOLATION_SRC_INDEX,
 …
     ep_lib::MPI_Recv((recvWeightBuff + receivedSize),
              recvBuffSize,
              MPI_DOUBLE,
+             EP_DOUBLE,
              clientSrcRank,
              MPI_DOMAIN_INTERPOLATION_WEIGHT,
 …
   std::vector<ep_lib::MPI_Status> requestStatus(sendRequest.size());
+  ep_lib::MPI_Waitall(sendRequest.size(), &sendRequest[0], &requestStatus[0]);
+  #ifdef _usingMPI
+  MPI_Waitall(sendRequest.size(), &sendRequest[0], MPI_STATUS_IGNORE);
+  #elif _usingEP
+  std::vector<ep_lib::MPI_Status> waitstat(sendRequest.size());
+  ep_lib::MPI_Waitall(sendRequest.size(), &sendRequest[0], &waitstat[0]);
+  #endif
   delete [] sendIndexDestBuff;
 …
   delete [] recvBuff;
+}
+CATCH
 /*! Redefined some functions of CONetCDF4 to make use of them */
 CDomainAlgorithmInterpolate::WriteNetCdf::WriteNetCdf(const StdString& filename, const ep_lib::MPI_Comm comm)
   : CNc4DataOutput(NULL, filename, false, false, true, comm, false, true) {}
-CDomainAlgorithmInterpolate::WriteNetCdf::WriteNetCdf(const StdString& filename, bool exist, const ep_lib::MPI_Comm comm)
-  : CNc4DataOutput(NULL, filename, exist, false, true, comm, false, true) {}
 int CDomainAlgorithmInterpolate::WriteNetCdf::addDimensionWrite(const StdString& name,
                                                                 const StdSize size)
+TRY
+{
   return CONetCDF4::addDimension(name, size);
+}
+CATCH
 int CDomainAlgorithmInterpolate::WriteNetCdf::addVariableWrite(const StdString& name, nc_type type,
                                                                const std::vector<StdString>& dim)
+TRY
+{
   return CONetCDF4::addVariable(name, type, dim);
+}
+CATCH
 void CDomainAlgorithmInterpolate::WriteNetCdf::endDefinition()
+TRY
+{
   CONetCDF4::definition_end();
+}
+CATCH
 void CDomainAlgorithmInterpolate::WriteNetCdf::writeDataIndex(const CArray<int,1>& data, const StdString& name,
 …
                                                               const std::vector<StdSize>* start,
                                                               const std::vector<StdSize>* count)
+TRY
+{
   CONetCDF4::writeData<int,1>(data, name, collective, record, start, count);
+}
+CATCH
 void CDomainAlgorithmInterpolate::WriteNetCdf::writeDataIndex(const CArray<double,1>& data, const StdString& name,
 …
                                                               const std::vector<StdSize>* start,
                                                               const std::vector<StdSize>* count)
+TRY
+{
   CONetCDF4::writeData<double,1>(data, name, collective, record, start, count);
+}
+CATCH
 /*
 …
 void CDomainAlgorithmInterpolate::writeInterpolationInfo(std::string& filename,
                                                          std::map<int,std::vector<std::pair<int,double> > >& interpMapValue)
+TRY
+{
   CContext* context = CContext::getCurrent();
 …
+  }
   ep_lib::MPI_Allreduce(&localNbWeight, &globalNbWeight, 1, MPI_LONG, MPI_SUM, client->intraComm);
   ep_lib::MPI_Scan(&localNbWeight, &startIndex, 1, MPI_LONG, MPI_SUM, client->intraComm);
+  ep_lib::MPI_Allreduce(&localNbWeight, &globalNbWeight, 1, EP_LONG, EP_SUM, client->intraComm);
+  ep_lib::MPI_Scan(&localNbWeight, &startIndex, 1, EP_LONG, EP_SUM, client->intraComm);
   if (0 == globalNbWeight)
 …
   std::vector<StdSize> count(1, localNbWeight);
+  int my_rank_loc = client->intraComm->ep_comm_ptr->size_rank_info[1].first;
+  int my_rank = client->intraComm->ep_comm_ptr->size_rank_info[0].first;
+  WriteNetCdf netCdfWriter(filename, client->intraComm);
+  // Define some dimensions
+  netCdfWriter.addDimensionWrite("n_src", n_src);
+  netCdfWriter.addDimensionWrite("n_dst", n_dst);
+  netCdfWriter.addDimensionWrite("n_weight", globalNbWeight);
+  WriteNetCdf *netCdfWriter;
+  MPI_Barrier_local(client->intraComm);
+  if(my_rank_loc==0)
+  {
+    info(100)<<"rank "<< my_rank <<" create weight info file"<< std::endl;
+    WriteNetCdf my_writer(filename, client->intraComm);
+    info(100)<<"rank "<< my_rank <<" file created"<< std::endl;
+    netCdfWriter = &my_writer;
+    // Define some dimensions
+    netCdfWriter->addDimensionWrite("n_src", n_src);
+    netCdfWriter->addDimensionWrite("n_dst", n_dst);
+    netCdfWriter->addDimensionWrite("n_weight", globalNbWeight);
+    info(100)<<"rank "<< my_rank <<" addDimensionWrite : n_src, n_dst, n_weight"<< std::endl;
+    std::vector<StdString> dims(1,"n_weight");
+    // Add some variables
+    netCdfWriter->addVariableWrite("src_idx", NC_INT, dims);
+    netCdfWriter->addVariableWrite("dst_idx", NC_INT, dims);
+    netCdfWriter->addVariableWrite("weight", NC_DOUBLE, dims);
+    info(100)<<"rank "<< my_rank <<" addVariableWrite : src_idx, dst_idx, weight"<< std::endl;
+    // End of definition
+    netCdfWriter->endDefinition();
+    info(100)<<"rank "<< my_rank <<" endDefinition"<< std::endl;
+    netCdfWriter->closeFile();
+    info(100)<<"rank "<< my_rank <<" file closed"<< std::endl;
+  }
+  MPI_Barrier_local(client->intraComm);
+  #pragma omp critical (write_weight_data)
+  {
+    // open file
+    info(100)<<"rank "<< my_rank <<" writing in weight info file"<< std::endl;
+    WriteNetCdf my_writer(filename, true, client->intraComm);
+    info(100)<<"rank "<< my_rank <<" file opened"<< std::endl;
+    netCdfWriter = &my_writer;
+    // // Write variables
+    if (0 != localNbWeight)
+    {
+      netCdfWriter->writeDataIndex(src_idx, "src_idx", false, 0, &start, &count);
+      netCdfWriter->writeDataIndex(dst_idx, "dst_idx", false, 0, &start, &count);
+      netCdfWriter->writeDataIndex(weights, "weight", false, 0, &start, &count);
+      info(100)<<"rank "<< my_rank <<" WriteDataIndex : src_idx, dst_idx, weight"<< std::endl;
+    }
+    netCdfWriter->closeFile();
+    info(100)<<"rank "<< my_rank <<" file closed"<< std::endl;
+  }
+  MPI_Barrier_local(client->intraComm);
+}
+  std::vector<StdString> dims(1,"n_weight");
+  // Add some variables
+  netCdfWriter.addVariableWrite("src_idx", NC_INT, dims);
+  netCdfWriter.addVariableWrite("dst_idx", NC_INT, dims);
+  netCdfWriter.addVariableWrite("weight", NC_DOUBLE, dims);
+  // End of definition
+  netCdfWriter.endDefinition();
+  // // Write variables
+  if (0 != localNbWeight)
+  {
+    netCdfWriter.writeDataIndex(src_idx, "src_idx", false, 0, &start, &count);
+    netCdfWriter.writeDataIndex(dst_idx, "dst_idx", false, 0, &start, &count);
+    netCdfWriter.writeDataIndex(weights, "weight", false, 0, &start, &count);
+  }
+  netCdfWriter.closeFile();
+}
+CATCH
 /*!
 …
 void CDomainAlgorithmInterpolate::readInterpolationInfo(std::string& filename,
                                                         std::map<int,std::vector<std::pair<int,double> > >& interpMapValue)
+TRY
+{
   int ncid ;
 …
+  }
+  #pragma omp critical (read_weight_data)
+  {
+    nc_open(filename.c_str(),NC_NOWRITE, &ncid) ;
+    nc_inq_dimid(ncid,"n_weight",&weightDimId) ;
+    nc_inq_dimlen(ncid,weightDimId,&nbWeightGlo) ;
+    size_t nbWeight ;
+    size_t start ;
+    size_t div = nbWeightGlo/clientSize ;
+    size_t mod = nbWeightGlo%clientSize ;
+    if (clientRank < mod)
+    {
+      nbWeight=div+1 ;
+      start=clientRank*(div+1) ;
+    }
+    else
+    {
+      nbWeight=div ;
+      start= mod * (div+1) + (clientRank-mod) * div ;
+    }
+    double* weight=new double[nbWeight] ;
+    int weightId ;
+    nc_inq_varid (ncid, "weight", &weightId) ;
+    nc_get_vara_double(ncid, weightId, &start, &nbWeight, weight) ;
+    long* srcIndex=new long[nbWeight] ;
+    int srcIndexId ;
+    nc_inq_varid (ncid, "src_idx", &srcIndexId) ;
+    nc_get_vara_long(ncid, srcIndexId, &start, &nbWeight, srcIndex) ;
+    long* dstIndex=new long[nbWeight] ;
+    int dstIndexId ;
+    nc_inq_varid (ncid, "dst_idx", &dstIndexId) ;
+    nc_get_vara_long(ncid, dstIndexId, &start, &nbWeight, dstIndex) ;
+    int indexOffset=0 ;
+    if (fortranConvention) indexOffset=1 ;
+      for(size_t ind=0; ind<nbWeight;++ind)
+        interpMapValue[dstIndex[ind]-indexOffset].push_back(make_pair(srcIndex[ind]-indexOffset,weight[ind]));
+  }
+}
+  nc_open(filename.c_str(),NC_NOWRITE, &ncid) ;
+  nc_inq_dimid(ncid,"n_weight",&weightDimId) ;
+  nc_inq_dimlen(ncid,weightDimId,&nbWeightGlo) ;
+  size_t nbWeight ;
+  size_t start ;
+  size_t div = nbWeightGlo/clientSize ;
+  size_t mod = nbWeightGlo%clientSize ;
+  if (clientRank < mod)
+  {
+    nbWeight=div+1 ;
+    start=clientRank*(div+1) ;
+  }
+  else
+  {
+    nbWeight=div ;
+    start= mod * (div+1) + (clientRank-mod) * div ;
+  }
+  double* weight=new double[nbWeight] ;
+  int weightId ;
+  nc_inq_varid (ncid, "weight", &weightId) ;
+  nc_get_vara_double(ncid, weightId, &start, &nbWeight, weight) ;
+  long* srcIndex=new long[nbWeight] ;
+  int srcIndexId ;
+  nc_inq_varid (ncid, "src_idx", &srcIndexId) ;
+  nc_get_vara_long(ncid, srcIndexId, &start, &nbWeight, srcIndex) ;
+  long* dstIndex=new long[nbWeight] ;
+  int dstIndexId ;
+  nc_inq_varid (ncid, "dst_idx", &dstIndexId) ;
+  nc_get_vara_long(ncid, dstIndexId, &start, &nbWeight, dstIndex) ;
+  int indexOffset=0 ;
+  if (fortranConvention) indexOffset=1 ;
+    for(size_t ind=0; ind<nbWeight;++ind)
+      interpMapValue[dstIndex[ind]-indexOffset].push_back(make_pair(srcIndex[ind]-indexOffset,weight[ind]));
+ }
+CATCH
 void CDomainAlgorithmInterpolate::apply(const std::vector<std::pair<int,double> >& localIndex,
 …
                                             std::vector<bool>& flagInitial,
                                             bool ignoreMissingValue, bool firstPass  )
+TRY
+{
   int nbLocalIndex = localIndex.size();
 …
+  }
+}
+CATCH
 void CDomainAlgorithmInterpolate::updateData(CArray<double,1>& dataOut)
+TRY
+{
   if (detectMissingValue)
 …
     size_t nbIndex=dataOut.numElements() ;
+    for (int idx = 0; idx < nbIndex; ++idx)
+    {
+      if (allMissing(idx)) dataOut(idx) = defaultValue; // If all data source are nan then data destination must be nan
+    if (allMissing.numElements()>0)
+    {
+      for (int idx = 0; idx < nbIndex; ++idx)
+      {
+        if (allMissing(idx)) dataOut(idx) = defaultValue; // If all data source are nan then data destination must be nan
+      }
+    }
 …
+  }
+}
+}
+CATCH
+}

XIOS/dev/branch_openmp/src/transformation/domain_algorithm_interpolate.hpp

-                      r1540
+                      r1642
 #ifndef __XIOS_DOMAIN_ALGORITHM_INTERPOLATE_HPP__
 #define __XIOS_DOMAIN_ALGORITHM_INTERPOLATE_HPP__
+#include "mpi_std.hpp"
 #include "domain_algorithm_transformation.hpp"
 #include "transformation.hpp"
 …
   public:
     WriteNetCdf(const StdString& filename, const ep_lib::MPI_Comm comm);
-    WriteNetCdf(const StdString& filename, bool exist, const ep_lib::MPI_Comm comm);
     int addDimensionWrite(const StdString& name, const StdSize size = UNLIMITED_DIM);
     int addVariableWrite(const StdString& name, nc_type type,

XIOS/dev/branch_openmp/src/transformation/domain_algorithm_reorder.cpp

r1460	r1642
19	19	std::map<int, int>& elementPositionInGridDst2AxisPosition,
20	20	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	21	TRY
21	22	{
22	23	std::vector<CDomain*> domainListDestP = gridDst->getDomains();
…	…
29	30	return (new CDomainAlgorithmReorder(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], reorderDomain));
30	31	}
	32	CATCH
31	33
32	34	bool CDomainAlgorithmReorder::registerTrans()
	35	TRY
33	36	{
34	37	CGridTransformationFactory<CDomain>::registerTransformation(TRANS_REORDER_DOMAIN, create);
35	38	}
	39	CATCH
36	40
37	41	CDomainAlgorithmReorder::CDomainAlgorithmReorder(CDomain* domainDestination, CDomain* domainSource, CReorderDomain* reorderDomain)
38	42	: CDomainAlgorithmTransformation(domainDestination, domainSource)
	43	TRY
39	44	{
40	45	reorderDomain->checkValid(domainSource);
…	…
109	114	}
110	115	}
111
112
113	116	}
	117	CATCH
114	118
115	119	/*!

XIOS/dev/branch_openmp/src/transformation/domain_algorithm_transformation.cpp

r1460	r1642
36	36	int elementType,
37	37	CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc)
	38	TRY
38	39	{
39	40	CContext* context = CContext::getCurrent();
…	…
65	66	globalDomainIndexOnProc = dhtIndexProcRank.getInfoIndexMap();
66	67	}
	68	CATCH
67	69
68	70	}

XIOS/dev/branch_openmp/src/transformation/domain_algorithm_zoom.cpp

-                      r1460
+                      r1642
-/*!
-   \file domain_algorithm_zoom.cpp
-   \author Ha NGUYEN
-   \since 02 Jul 2015
-   \date 02 Jul 2015
-   \brief Algorithm for zooming on an domain.
- */
 #include "domain_algorithm_zoom.hpp"
 #include "zoom_domain.hpp"
 …
 #include "grid.hpp"
 #include "grid_transformation_factory_impl.hpp"
+#include "attribute_template.hpp"
 namespace xios {
 …
                                                              std::map<int, int>& elementPositionInGridDst2AxisPosition,
                                                              std::map<int, int>& elementPositionInGridDst2DomainPosition)
+TRY
+{
   std::vector<CDomain*> domainListDestP = gridDst->getDomains();
 …
   return (new CDomainAlgorithmZoom(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], zoomDomain));
+}
+CATCH
 bool CDomainAlgorithmZoom::registerTrans()
+TRY
+{
   CGridTransformationFactory<CDomain>::registerTransformation(TRANS_ZOOM_DOMAIN, create);
+}
+CATCH
 CDomainAlgorithmZoom::CDomainAlgorithmZoom(CDomain* domainDestination, CDomain* domainSource, CZoomDomain* zoomDomain)
 : CDomainAlgorithmTransformation(domainDestination, domainSource)
+TRY
+{
   zoomDomain->checkValid(domainSource);
 …
            << "Zoom size is " << zoomNj_ );
+  }
+}
+  // Calculate the size of local domain
+  int ind, indLocSrc, indLocDest, iIdxSrc, jIdxSrc, destIBegin = -1, destJBegin = -1, niDest = 0, njDest = 0, ibeginDest, jbeginDest ;
+  int indGloDest, indGloSrc, niGloSrc = domainSrc_->ni_glo, iSrc, jSrc, nvertex = 0;
+  for (int j = 0; j < domainSrc_->nj.getValue(); j++)
+  {
+    for (int i = 0; i < domainSrc_->ni.getValue(); i++)
+    {
+      ind = j*domainSrc_->ni + i;
+      iIdxSrc = domainSrc_->i_index(ind);
+      if ((iIdxSrc >= zoomIBegin_) && (iIdxSrc <= zoomIEnd_))
+      {
+        jIdxSrc = domainSrc_->j_index(ind);
+        if ((jIdxSrc >= zoomJBegin_) && (jIdxSrc <= zoomJEnd_))
+        {
+          if ((niDest == 0) && (njDest == 0))
+          {
+            destIBegin = i;
+            destJBegin = j;
+          }
+          if (i == destIBegin) ++njDest;
+        }
+        if (j == destJBegin) ++niDest;
+      }
+    }
+  }
+  ibeginDest = destIBegin + domainSrc_->ibegin - zoomIBegin_;
+  jbeginDest = destJBegin + domainSrc_->jbegin - zoomJBegin_;
+  domainDest_->ni_glo.setValue(zoomNi_);
+  domainDest_->nj_glo.setValue(zoomNj_);
+  domainDest_->ni.setValue(niDest);
+  domainDest_->nj.setValue(njDest);
+  if ( (niDest==0) || (njDest==0))
+  {
+    domainDest_->ibegin.setValue(0);
+    domainDest_->jbegin.setValue(0);
+  }
+  else
+  {
+    domainDest_->ibegin.setValue(ibeginDest);
+    domainDest_->jbegin.setValue(jbeginDest);
+  }
+  domainDest_->i_index.resize(niDest*njDest);
+  domainDest_->j_index.resize(niDest*njDest);
+  domainDest_->data_ni.setValue(niDest);
+  domainDest_->data_nj.setValue(njDest);
+  domainDest_->data_ibegin.setValue(0);
+  domainDest_->data_jbegin.setValue(0);
+  domainDest_->data_i_index.resize(niDest*njDest);
+  domainDest_->data_j_index.resize(niDest*njDest);
+  domainDest_->domainMask.resize(niDest*njDest);
+  if (!domainSrc_->lonvalue_1d.isEmpty())
+  {
+    if (domainDest_->type == CDomain::type_attr::rectilinear)
+    {
+      domainDest_->lonvalue_1d.resize(niDest);
+      domainDest_->latvalue_1d.resize(njDest);
+    }
+    else if (domainDest_->type == CDomain::type_attr::unstructured)
+    {
+      domainDest_->lonvalue_1d.resize(niDest);
+      domainDest_->latvalue_1d.resize(niDest);
+    }
+    else if (domainDest_->type == CDomain::type_attr::curvilinear)
+    {
+      domainDest_->lonvalue_1d.resize(niDest*njDest);
+      domainDest_->latvalue_1d.resize(niDest*njDest);
+    }
+  }
+  else if (!domainSrc_->lonvalue_2d.isEmpty())
+  {
+    domainDest_->lonvalue_2d.resize(niDest,njDest);
+    domainDest_->latvalue_2d.resize(niDest,njDest);
+  }
+  if (domainSrc_->hasBounds)
+  {
+    nvertex = domainSrc_->nvertex;
+    domainDest_->nvertex.setValue(nvertex);
+    if (!domainSrc_->bounds_lon_1d.isEmpty())
+    {
+      if (domainDest_->type == CDomain::type_attr::rectilinear)
+      {
+        domainDest_->bounds_lon_1d.resize(nvertex, niDest);
+        domainDest_->bounds_lat_1d.resize(nvertex, njDest);
+      }
+      else if (domainDest_->type == CDomain::type_attr::unstructured)
+      {
+        domainDest_->bounds_lon_1d.resize(nvertex, niDest);
+        domainDest_->bounds_lat_1d.resize(nvertex, niDest);
+      }
+      else if (domainDest_->type == CDomain::type_attr::curvilinear)
+      {
+        domainDest_->bounds_lon_1d.resize(nvertex, niDest*njDest);
+        domainDest_->bounds_lat_1d.resize(nvertex, niDest*njDest);
+      }
+    }
+    else if (!domainSrc_->bounds_lon_2d.isEmpty())
+    {
+      domainDest_->bounds_lon_2d.resize(nvertex, niDest, njDest);
+      domainDest_->bounds_lat_2d.resize(nvertex, niDest, njDest);
+    }
+  }
+  if (domainSrc_->hasArea) domainDest_->area.resize(niDest,njDest);
+  this->transformationMapping_.resize(1);
+  this->transformationWeight_.resize(1);
+  TransformationIndexMap& transMap = this->transformationMapping_[0];
+  TransformationWeightMap& transWeight = this->transformationWeight_[0];
+  for (int iDest = 0; iDest < niDest; iDest++)
+  {
+    iSrc = iDest + destIBegin;
+    for (int jDest = 0; jDest < njDest; jDest++)
+    {
+      jSrc = jDest + destJBegin;
+      ind = jSrc * domainSrc_->ni + iSrc;
+      iIdxSrc = domainSrc_->i_index(ind);
+      jIdxSrc = domainSrc_->j_index(ind);
+      indLocDest = jDest*niDest + iDest;
+      indGloDest = (jDest + jbeginDest)*zoomNi_ + (iDest + ibeginDest);
+      indLocSrc = (jDest+destJBegin)*domainSrc_->ni + (iDest+destIBegin);
+      indGloSrc = (jIdxSrc )* niGloSrc + iIdxSrc;
+      domainDest_->i_index(indLocDest) = iDest + ibeginDest;                                             // i_index contains global positions
+      domainDest_->j_index(indLocDest) = jDest + jbeginDest;                                             // i_index contains global positions
+      domainDest_->data_i_index(indLocDest) = (domainSrc_->data_dim == 1) ? indLocDest : iDest;          // data_i_index contains local positions
+      domainDest_->data_j_index(indLocDest) = (domainSrc_->data_dim == 1) ? 0 :jDest;                    // data_i_index contains local positions
+      domainDest_->domainMask(indLocDest) = domainSrc_->domainMask(indLocSrc);
+      if (domainSrc_->hasArea)
+        domainDest_->area(iDest,jDest) = domainSrc_->area(iSrc,jSrc);
+      if (domainSrc_->hasLonLat)
+      {
+        if (!domainSrc_->latvalue_1d.isEmpty())
+        {
+          if (domainDest_->type == CDomain::type_attr::rectilinear)
+          {
+            domainDest_->latvalue_1d(jDest) = domainSrc_->latvalue_1d(jSrc);
+          }
+          else
+          {
+            domainDest_->lonvalue_1d(indLocDest) = domainSrc_->lonvalue_1d(ind);
+            domainDest_->latvalue_1d(indLocDest) = domainSrc_->latvalue_1d(ind);
+          }
+        }
+        else if (!domainSrc_->latvalue_2d.isEmpty())
+        {
+          domainDest_->lonvalue_2d(iDest,jDest) = domainSrc_->lonvalue_2d(iSrc,jSrc);
+          domainDest_->latvalue_2d(iDest,jDest) = domainSrc_->latvalue_2d(iSrc,jSrc);
+        }
+      }
+      if (domainSrc_->hasBounds)
+      {
+        if (!domainSrc_->bounds_lon_1d.isEmpty())
+        {
+          if (domainDest_->type == CDomain::type_attr::rectilinear)
+          {
+            for (int n = 0; n < nvertex; ++n)
+              domainDest_->bounds_lat_1d(n,jDest) = domainSrc_->bounds_lat_1d(n,jSrc);
+          }
+          else
+          {
+            for (int n = 0; n < nvertex; ++n)
+            {
+              domainDest_->bounds_lon_1d(n,indLocDest) = domainSrc_->bounds_lon_1d(n,ind);
+              domainDest_->bounds_lat_1d(n,indLocDest) = domainSrc_->bounds_lat_1d(n,ind);
+            }
+          }
+        }
+        else if (!domainSrc_->bounds_lon_2d.isEmpty())
+        {
+          for (int n = 0; n < nvertex; ++n)
+          {
+            domainDest_->bounds_lon_2d(n,iDest,jDest) = domainSrc_->bounds_lon_2d(n,iSrc,jSrc);
+            domainDest_->bounds_lat_2d(n,iDest,jDest) = domainSrc_->bounds_lat_2d(n,iSrc,jSrc);
+          }
+        }
+      }
+      transMap[indGloDest].push_back(indGloSrc);
+      transWeight[indGloDest].push_back(1.0);
+    }
+    if (domainSrc_->hasLonLat && !domainSrc_->latvalue_1d.isEmpty())
+    {
+      if (domainDest_->type == CDomain::type_attr::rectilinear)
+      {
+        domainDest_->lonvalue_1d(iDest) = domainSrc_->lonvalue_1d(iSrc);
+      }
+    }
+    if (domainSrc_->hasBounds && !domainSrc_->bounds_lon_1d.isEmpty())
+    {
+      if (domainDest_->type == CDomain::type_attr::rectilinear)
+      {
+        for (int n = 0; n < nvertex; ++n)
+          domainDest_->bounds_lon_1d(n,iDest) = domainSrc_->bounds_lon_1d(n,iSrc);
+      }
+    }
+  }
+  domainDest_->computeLocalMask();
+}
+CATCH
 /*!
 …
 void CDomainAlgorithmZoom::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
+{
+  int niGlob = domainSrc_->ni_glo.getValue();
+  int njGlob = domainSrc_->nj_glo.getValue();
+  this->transformationMapping_.resize(1);
+  this->transformationWeight_.resize(1);
+  TransformationIndexMap& transMap = this->transformationMapping_[0];
+  TransformationWeightMap& transWeight = this->transformationWeight_[0];
+  int domainGlobalIndex;
+  int iglob ;
+  int jglob ;
+  const CArray<int,1>& i_index = domainSrc_->i_index.getValue() ;
+  const CArray<int,1>& j_index = domainSrc_->j_index.getValue() ;
+  int nglo = i_index.numElements() ;
+  for (size_t i = 0; i < nglo ; ++i)
+  {
+    iglob=i_index(i) ; jglob=j_index(i) ;
+    if (iglob>=zoomIBegin_ && iglob<=zoomIEnd_ && jglob>=zoomJBegin_ && jglob<=zoomJEnd_)
+    {
+      domainGlobalIndex = jglob*niGlob + iglob;
+      transMap[domainGlobalIndex].push_back(domainGlobalIndex);
+      transWeight[domainGlobalIndex].push_back(1.0);
+    }
+  }
+  updateZoom();
+}
+/*!
+  After a zoom on domain, it should be certain that (global) zoom begin and (global) zoom size are updated
+*/
+void CDomainAlgorithmZoom::updateZoom()
+{
+  domainDest_->global_zoom_ibegin = zoomIBegin_;
+  domainDest_->global_zoom_jbegin = zoomJBegin_;
+  domainDest_->global_zoom_ni  = zoomNi_;
+  domainDest_->global_zoom_nj  = zoomNj_;
+}
+/*!
+  Update mask on domain
+  Because only zoomed region on domain is not masked, the remaining must be masked to make sure
+correct index be extracted
+*/
+// void CDomainAlgorithmZoom::updateDomainDestinationMask()
+// {
+//   int niMask     = domainDest_->ni.getValue();
+//   int iBeginMask = domainDest_->ibegin.getValue();
+//   int njMask     = domainDest_->nj.getValue();
+//   int jBeginMask = domainDest_->jbegin.getValue();
+//   int niGlob = domainDest_->ni_glo.getValue();
+//   int globalIndexMask = 0;
+//   TransformationIndexMap& transMap = this->transformationMapping_[0];
+//   TransformationIndexMap::const_iterator ite = (transMap).end();
+//   for (int j = 0; j < njMask; ++j)
+//   {
+//     for (int i = 0; i < niMask; ++i)
+//     {
+//       globalIndexMask = (j+jBeginMask) * niGlob + (i + iBeginMask);
+//       if (transMap.find(globalIndexMask) == ite)
+//         (domainDest_->mask_1d)(i+j*niMask) = false;
+//     }
+//   }
+// }
+}
+}
+}

XIOS/dev/branch_openmp/src/transformation/domain_algorithm_zoom.hpp

-                      r1460
+                      r1642
-/*!
-   \file domain_algorithm_zoom.hpp
-   \author Ha NGUYEN
-   \since 03 June 2015
-   \date 12 June 2015
-   \brief Algorithm for zooming on an domain.
- */
 #ifndef __XIOS_DOMAIN_ALGORITHM_ZOOM_HPP__
 #define __XIOS_DOMAIN_ALGORITHM_ZOOM_HPP__
 …
 /*!
   \class CDomainAlgorithmZoom
+  Implementing zoom on domain
+  A zoomed region can be considered as region that isnt masked.
+  Only this zoomed region is extracted to write on Netcdf.
+  Implementing zoom (alternative zoom) on domain
 */
 class CDomainAlgorithmZoom : public CDomainAlgorithmTransformation
 …
   static bool registerTrans();
 protected:
+  void updateDomainAttributes();
   void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs);
 private:
-  // void updateDomainDestinationMask();
   void updateZoom();

XIOS/dev/branch_openmp/src/transformation/generic_algorithm_transformation.cpp

r1545	r1642
34	34	std::vector<bool>& flagInitial,
35	35	bool ignoreMissingValue, bool firstPass )
	36	TRY
36	37	{
37	38	int nbLocalIndex = localIndex.size();
38	39	double defaultValue = std::numeric_limits<double>::quiet_NaN();
39
	40
40	41	if (ignoreMissingValue)
41	42	{
42	43	if (firstPass) dataOut=defaultValue ;
43
	44
44	45	for (int idx = 0; idx < nbLocalIndex; ++idx)
45	46	{
…	…
61	62	}
62	63	}
	64	CATCH
63	65
64	66	void CGenericAlgorithmTransformation::computePositionElements(CGrid* dst, CGrid* src)
	67	TRY
65	68	{
66	69	int idxScalar = 0, idxAxis = 0, idxDomain = 0;
…	…
108	111	}
109	112	}
	113	CATCH
110	114
111	115	bool CGenericAlgorithmTransformation::isDistributedTransformation(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst)
	116	TRY
112	117	{
113	118
…	…
131	136	{
132	137	distributed=domainListSrcP[elementPositionInGridSrc2DomainPosition_[elementPositionInGrid]]->isDistributed() ;
133		ep_lib::MPI_Allreduce(&distributed,&distributed_glo, 1, ~~MPI_INT, MPI~~_LOR, client->intraComm) ;
	138	ep_lib::MPI_Allreduce(&distributed,&distributed_glo, 1, EP_INT, EP_LOR, client->intraComm) ;
134	139
135	140	}
…	…
137	142	{
138	143	distributed=axisListSrcP[elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]]->isDistributed() ;
139		ep_lib::MPI_Allreduce(&distributed,&distributed_glo, 1, ~~MPI_INT, MPI~~_LOR, client->intraComm) ;
	144	ep_lib::MPI_Allreduce(&distributed,&distributed_glo, 1, EP_INT, EP_LOR, client->intraComm) ;
140	145	}
141	146	else //it's a scalar
…	…
147	152	}
148	153	return isDistributed_ ;
149		}
	154	}
	155	CATCH
	156
150	157	/*!
151	158	This function computes the global indexes of grid source, which the grid destination is in demand.
…	…
160	167	CGrid* gridDst,
161	168	SourceDestinationIndexMap& globaIndexWeightFromSrcToDst)
	169	TRY
162	170	{
163	171	CContext* context = CContext::getCurrent();
…	…
230	238	int sendValue = (computeGlobalIndexOnProc) ? 1 : 0;
231	239	int recvValue = 0;
232		ep_lib::MPI_Allreduce(&sendValue, &recvValue, 1, ~~MPI_INT, MPI~~_SUM, client->intraComm);
	240	ep_lib::MPI_Allreduce(&sendValue, &recvValue, 1, EP_INT, EP_SUM, client->intraComm);
233	241	computeGlobalIndexOnProc = (0 < recvValue);
234	242
…	…
443	451	}
444	452	}
	453	CATCH
445	454
446	455	/*!
…	…
461	470	std::vector<std::unordered_map<int,std::vector<size_t> > >& globalElementIndexOnProc,
462	471	SourceDestinationIndexMap& globaIndexWeightFromSrcToDst)
	472	TRY
463	473	{
464	474	SourceDestinationIndexMap globaIndexWeightFromSrcToDst_tmp ;
…	…
640	650	}
641	651	}
642
643		}
	652	}
	653	CATCH
644	654
645	655	/*!
…	…
654	664	CArray<size_t,1>& destGlobalIndexPositionInGrid,
655	665	std::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc)
	666	TRY
656	667	{
657	668	CContext* context = CContext::getCurrent();
…	…
666	677	}
667	678	}
	679	CATCH
668	680
669	681	/*!
…	…
678	690	CArray<size_t,1>& destGlobalIndexPositionInGrid,
679	691	std::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc)
	692	TRY
680	693	{
681	694	CContext* context = CContext::getCurrent();
…	…
735	748	}
736	749	}
	750	CATCH
737	751
738	752	/*!
…	…
747	761	CArray<size_t,1>& destGlobalIndexPositionInGrid,
748	762	std::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc)
	763	TRY
749	764	{
750	765	CContext* context = CContext::getCurrent();
…	…
838	853	}
839	854	}
840
841
842
843
844
	855	CATCH
845	856
846	857	void CGenericAlgorithmTransformation::computeTransformationMappingNonDistributed(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst,
847		vector<int>& localSrc, vector<int>& localDst, vector<double>& weight, vector<bool>& localMaskOnGridDest)
	858	vector<int>& localSrc, vector<int>& localDst, vector<double>& weight,
	859	int& nlocalIndexDest)
	860	TRY
848	861	{
849	862
…	…
871	884
872	885	int nlocalIndexSrc=1 ;
873		int nlocalIndexDest=1 ;
	886	// int nlocalIndexDest=1 ;
	887	nlocalIndexDest=1 ;
874	888	CArray<bool,1> maskScalar(1) ;
875	889	maskScalar = true ;
…	…
933	947	nlocalIndexDest=nlocalIndexDest*nIndexDst[i] ;
934	948	}
935
936
937
938
939
940	949
941	950	vector<int> dstLocalInd ;
…	…
985	994	}
986	995
987		~~// just get the local src mask~~
988		~~CArray<bool,1> localMaskOnSrcGrid;~~
989		~~gridSrc->getLocalMask(localMaskOnSrcGrid) ;~~
990		~~// intermediate grid, mask is not initialized => set up mask to true~~
991		~~if (localMaskOnSrcGrid.isEmpty())~~
992		{
993		~~localMaskOnSrcGrid.resize(nlocalIndexSrc) ;~~
994		~~localMaskOnSrcGrid=true ;~~
995		}
996
997
998		~~localMaskOnGridDest.resize(nlocalIndexDest,false) ;~~
999
1000	996	vector<vector<vector<pair<int,double> > > > dstIndWeight(transformationMapping_.size()) ;
1001	997
…	…
1024	1020
1025	1021	nonDistributedrecursiveFunct(nElement-1,true,elementPositionInGrid,maskSrc,maskDst, srcInd, srcIndCompressed, nIndexSrc, t, dstIndWeight,
1026		currentInd,localSrc,localDst,weight~~, localMaskOnSrcGrid, localMaskOnGridDest~~ );
	1022	currentInd,localSrc,localDst,weight);
1027	1023
1028	1024	}
1029
1030
1031		void CGenericAlgorithmTransformation::nonDistributedrecursiveFunct(int currentPos, bool masked, int elementPositionInGrid, vector< CArray<bool,1>* >& maskSrc, vector< CArray<bool,1>* >& maskDst, int& srcInd, int& srcIndCompressed, vector<int>& nIndexSrc, int& t, vector<vector<vector<pair<int,double> > > >& dstIndWeight, int currentInd,
1032		vector<int>& localSrc, vector<int>& localDst, vector<double>& weight, CArray<bool,1>& localMaskOnGridSrc, vector<bool>& localMaskOnGridDest )
	1025	CATCH
	1026
	1027
	1028	void CGenericAlgorithmTransformation::nonDistributedrecursiveFunct(int currentPos, bool masked, int elementPositionInGrid,
	1029	vector< CArray<bool,1>* >& maskSrc, vector< CArray<bool,1>* >& maskDst,
	1030	int& srcInd, int& srcIndCompressed, vector<int>& nIndexSrc,
	1031	int& t, vector<vector<vector<pair<int,double> > > >& dstIndWeight, int currentInd,
	1032	vector<int>& localSrc, vector<int>& localDst, vector<double>& weight)
	1033	TRY
1033	1034	{
1034	1035	int masked_ ;
…	…
1043	1044	masked_=masked ;
1044	1045	if (!mask(i)) masked_=false ;
1045		nonDistributedrecursiveFunct(currentPos-1, masked_, elementPositionInGrid, maskSrc, maskDst, srcInd, srcIndCompressed, nIndexSrc, t, dstIndWeight, currentInd, localSrc, localDst, weight, localMaskOnGridSrc, localMaskOnGridDest) ;
	1046	nonDistributedrecursiveFunct(currentPos-1, masked_, elementPositionInGrid, maskSrc, maskDst, srcInd, srcIndCompressed, nIndexSrc, t,
	1047	dstIndWeight, currentInd, localSrc, localDst, weight);
1046	1048	}
1047	1049	}
…	…
1057	1059	for(vector<pair<int,double> >::iterator it = dstIndWeight[t][currentInd].begin(); it!=dstIndWeight[t][currentInd].end(); ++it)
1058	1060	{
1059		if (localMaskOnGridSrc(srcInd))
1060		{
1061		localSrc.push_back(srcIndCompressed) ;
1062		localDst.push_back(it->first) ;
1063		weight.push_back(it->second) ;
1064		localMaskOnGridDest[it->first]=true ;
1065		}
	1061	localSrc.push_back(srcIndCompressed) ;
	1062	localDst.push_back(it->first) ;
	1063	weight.push_back(it->second) ;
1066	1064	(it->first)++ ;
1067	1065	}
1068	1066	}
1069	1067	if (t < dstIndWeight.size()-1) t++ ;
1070		~~if (localMaskOnGridSrc(srcInd))~~ srcIndCompressed ++ ;
	1068	srcIndCompressed ++ ;
1071	1069	}
1072	1070	srcInd++ ;
…	…
1086	1084	masked_=masked ;
1087	1085	if (!mask(i)) masked_=false ;
1088		nonDistributedrecursiveFunct(currentPos-1, masked_, elementPositionInGrid, maskSrc, maskDst, srcInd, srcIndCompressed, nIndexSrc, t, dstIndWeight , i, localSrc, localDst, weight, localMaskOnGridSrc, localMaskOnGridDest) ;
	1086	nonDistributedrecursiveFunct(currentPos-1, masked_, elementPositionInGrid, maskSrc, maskDst, srcInd,
	1087	srcIndCompressed, nIndexSrc, t, dstIndWeight , i, localSrc, localDst, weight);
1089	1088	}
1090	1089	}
…	…
1100	1099	for(vector<pair<int,double> >::iterator it = dstIndWeight[t][i].begin(); it!=dstIndWeight[t][i].end(); ++it)
1101	1100	{
1102		if (localMaskOnGridSrc(srcInd))
1103		{
1104		localSrc.push_back(srcIndCompressed) ;
1105		localDst.push_back(it->first) ;
1106		weight.push_back(it->second) ;
1107		localMaskOnGridDest[it->first]=true ;
1108		}
	1101	localSrc.push_back(srcIndCompressed) ;
	1102	localDst.push_back(it->first) ;
	1103	weight.push_back(it->second) ;
1109	1104	(it->first)++ ;
1110	1105	}
1111	1106	}
1112	1107	if (t < dstIndWeight.size()-1) t++ ;
1113		~~if (localMaskOnGridSrc(srcInd))~~ srcIndCompressed ++ ;
	1108	srcIndCompressed ++ ;
1114	1109	}
1115	1110	srcInd++ ;
…	…
1119	1114
1120	1115	}
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
	1116	CATCH
1131	1117
1132	1118	/*!
…	…
1136	1122	*/
1137	1123	void CGenericAlgorithmTransformation::computeIndexSourceMapping(const std::vector<CArray<double,1>* >& dataAuxInputs)
	1124	TRY
1138	1125	{
1139	1126	computeIndexSourceMapping_(dataAuxInputs);
1140	1127	}
	1128	CATCH
1141	1129
1142	1130	std::vector<StdString> CGenericAlgorithmTransformation::getIdAuxInputs()
	1131	TRY
1143	1132	{
1144	1133	return idAuxInputs_;
1145	1134	}
	1135	CATCH
1146	1136
1147	1137	CGenericAlgorithmTransformation::AlgoTransType CGenericAlgorithmTransformation::type()
	1138	TRY
1148	1139	{
1149	1140	return type_;
1150	1141	}
1151
1152		}
	1142	CATCH
	1143
	1144	}

XIOS/dev/branch_openmp/src/transformation/generic_algorithm_transformation.hpp

-                      r1545
+                      r1642
   void computeIndexSourceMapping(const std::vector<CArray<double,1>* >& dataAuxInputs = std::vector<CArray<double,1>* >());
   void computeTransformationMappingNonDistributed(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst,
+                                                  vector<int>& localSrc, vector<int>& localDst, vector<double>& weight, vector<bool>& localMaskOnGridDest);
+  void nonDistributedrecursiveFunct(int currentPos, bool masked, int elementPositionInGrid,  vector< CArray<bool,1>* >& maskSrc, vector< CArray<bool,1>* >& maskDst, int& srcInd, int& srcIndCompressed, vector<int>& nIndexSrc, int& t, vector<vector<vector<pair<int,double> > > >& dstIndWeight, int currentInd,
+                                     vector<int>& localSrc, vector<int>& localDst, vector<double>& weight, CArray<bool,1>& localMaskOnGridSrc, vector<bool>& localMaskOnGridDest) ;
+                                                  vector<int>& localSrc, vector<int>& localDst, vector<double>& weight, int& nbLocalIndexOnGridDest);
+  void nonDistributedrecursiveFunct(int currentPos, bool masked, int elementPositionInGrid,  vector< CArray<bool,1>* >& maskSrc, vector< CArray<bool,1>* >& maskDst,
+                                    int& srcInd, int& srcIndCompressed, vector<int>& nIndexSrc,
+                                    int& t, vector<vector<vector<pair<int,double> > > >& dstIndWeight, int currentInd,
+                                    vector<int>& localSrc, vector<int>& localDst, vector<double>& weight) ;
 protected:

XIOS/dev/branch_openmp/src/transformation/grid_generate.cpp

r978	r1642
30	30	*/
31	31	void CGridGenerate::selectScalarAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
	32	TRY
32	33	{
33	34	CGenericAlgorithmTransformation* algo = 0;
34	35	algoTransformation_.push_back(algo);
35	36	}
	37	CATCH
36	38
37	39	/*!
…	…
43	45	*/
44	46	void CGridGenerate::selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
	47	TRY
45	48	{
46	49	CGenericAlgorithmTransformation* algo = 0;
47	50	algoTransformation_.push_back(algo);
48	51	}
	52	CATCH
49	53
50	54	/*!
…	…
56	60	*/
57	61	void CGridGenerate::selectDomainAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
	62	TRY
58	63	{
59	64	std::vector<CDomain*> domainListDestP = gridDestination_->getDomains();
…	…
89	94	algoTransformation_.push_back(algo);
90	95	}
	96	CATCH
91	97
92	98	/*!
…	…
94	100	*/
95	101	void CGridGenerate::completeGrid()
	102	TRY
96	103	{
97	104	ListAlgoType::const_iterator itb = listAlgos_.begin(),
…	…
110	117	}
111	118	}
	119	CATCH
112	120
113	121	}

XIOS/dev/branch_openmp/src/transformation/grid_transformation.cpp

-                      r1545
+                      r1642
 */
 void CGridTransformation::selectScalarAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
+TRY
+{
   std::vector<CScalar*> scaListDestP = gridDestination_->getScalars();
 …
   algoTransformation_.push_back(algo);
+}
+CATCH
 /*!
 …
 */
 void CGridTransformation::selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
+TRY
+{
   std::vector<CAxis*> axisListDestP = gridDestination_->getAxis();
 …
   algoTransformation_.push_back(algo);
+}
+CATCH
 /*!
 …
 */
 void CGridTransformation::selectDomainAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
+TRY
+{
   std::vector<CDomain*> domainListDestP = gridDestination_->getDomains();
 …
   algoTransformation_.push_back(algo);
+}
+CATCH
 /*!
 …
 */
 std::map<int,std::pair<int,int> > CGridTransformation::getElementPosition(CGrid* grid)
+TRY
+{
   std::vector<CScalar*> scalarListP = grid->getScalars();
 …
   return elementPosition;
+}
+CATCH
 /*!
 …
 */
 void CGridTransformation::setUpGridDestination(int elementPositionInGrid, ETranformationType transType)
+TRY
+{
   if (isSpecialTransformation(transType)) return;
 …
   tempGridDests_.push_back(tmpGridDestination_);
+}
+CATCH
 /*!
 …
 */
 void CGridTransformation::setUpGridSource(int elementPositionInGrid)
+TRY
+{
   if (!tempGridSrcs_.empty() && (getNbAlgo()-1) == tempGridSrcs_.size())
 …
   tempGridSrcs_.push_back(gridSource_);
+}
+CATCH
 /*!
 …
 */
 void CGridTransformation::computeAll(const std::vector<CArray<double,1>* >& dataAuxInputs, Time timeStamp)
+TRY
+{
   if (nbNormalAlgos_ < 1) return;
 …
       std::list<RecvIndexGridDestinationMap>().swap(localIndexToReceiveOnGridDest_);
       std::list<size_t>().swap(nbLocalIndexOnGridDest_);
-      std::list<std::vector<bool> >().swap(localMaskOnGridDest_);
+    }
     else
 …
         vector<int> localDst ;
         vector<double> weight ;
         localMaskOnGridDest_.push_back(vector<bool>()) ;
+        int nbLocalIndexOnGridDest;
         CTimer::get("computeTransformationMappingNonDistributed").resume();
         algo->computeTransformationMappingNonDistributed(elementPosition, gridSource_, tmpGridDestination_,
                                                          localSrc, localDst, weight, localMaskOnGridDest_.back()) ;
+                                                         localSrc, localDst, weight, nbLocalIndexOnGridDest) ;
         CTimer::get("computeTransformationMappingNonDistributed").suspend();
         CTimer::get("computeTransformationMappingConvert").resume();
         nbLocalIndexOnGridDest_.push_back(localMaskOnGridDest_.back().size()) ;
+        nbLocalIndexOnGridDest_.push_back(nbLocalIndexOnGridDest) ;
         int clientRank=client->clientRank ;
+        {
 …
+  }
+}
+CATCH
 /*!
 …
 */
 void CGridTransformation::computeTransformationMapping(const SourceDestinationIndexMap& globaIndexWeightFromSrcToDst)
+TRY
+{
   CContext* context = CContext::getCurrent();
 …
   size_t nbLocalIndex = globalLocalIndexGridDestSendToServer.size();
   nbLocalIndexOnGridDest_.push_back(nbLocalIndex);
   localMaskOnGridDest_.push_back(std::vector<bool>());
   std::vector<bool>& tmpMask = localMaskOnGridDest_.back();
   tmpMask.resize(nbLocalIndex,false);
+//  localMaskOnGridDest_.push_back(std::vector<bool>());
+//  std::vector<bool>& tmpMask = localMaskOnGridDest_.back();
+//  tmpMask.resize(nbLocalIndex,false);
   // Find out number of index sent from grid source and number of index received on grid destination
 …
     sendRankSizeMap[itIndex->first] = sendSize;
+  }
   ep_lib::MPI_Allgather(&connectedClient,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm);
+  ep_lib::MPI_Allgather(&connectedClient,1,EP_INT,recvCount,1,EP_INT,client->intraComm);
   displ[0]=0 ;
 …
   int* recvRankBuff=new int[recvSize];
   int* recvSizeBuff=new int[recvSize];
   ep_lib::MPI_Allgatherv(sendRankBuff,connectedClient,MPI_INT,recvRankBuff,recvCount,displ,MPI_INT,client->intraComm);
   ep_lib::MPI_Allgatherv(sendSizeBuff,connectedClient,MPI_INT,recvSizeBuff,recvCount,displ,MPI_INT,client->intraComm);
+  ep_lib::MPI_Allgatherv(sendRankBuff,connectedClient,EP_INT,recvRankBuff,recvCount,displ,EP_INT,client->intraComm);
+  ep_lib::MPI_Allgatherv(sendSizeBuff,connectedClient,EP_INT,recvSizeBuff,recvCount,displ,EP_INT,client->intraComm);
   for (int i = 0; i < nbClient; ++i)
+  {
 …
     recvGlobalIndexSrc[recvRank] = new unsigned long [recvSize];
+    ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, MPI_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests[requests_position++]);
+    ep_lib::MPI_Irecv(recvMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests[requests_position++]);
+    ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests[requests_position++]);
+    ep_lib::MPI_Irecv(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests[requests_position++]);
+    //requests.push_back(ep_lib::MPI_Request());
+    //ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back());
+    //requests.push_back(ep_lib::MPI_Request());
+    //ep_lib::MPI_Irecv(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests.back());
+  }
 …
     // Send global index source and mask
+    ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, MPI_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests[requests_position++]);
+    ep_lib::MPI_Isend(sendMaskDst[sendRank], sendSize, MPI_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests[requests_position++]);
+    ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests[requests_position++]);
+    ep_lib::MPI_Isend(sendMaskDst[sendRank], sendSize, EP_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests[requests_position++]);
+    //requests.push_back(ep_lib::MPI_Request());
+    //ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back());
+    //requests.push_back(ep_lib::MPI_Request());
+    //ep_lib::MPI_Isend(sendMaskDst[sendRank], sendSize, EP_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests.back());
+  }
 …
     int recvSize = itSend->second;
+    ep_lib::MPI_Irecv(sendMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests[requests_position++]);
+    ep_lib::MPI_Irecv(sendMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests[requests_position++]);
+    //requests.push_back(ep_lib::MPI_Request());
+    //ep_lib::MPI_Irecv(sendMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back());
+  }
 …
     // Okie, now inform the destination which source index are masked
+    ep_lib::MPI_Isend(recvMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests[requests_position++]);
+    ep_lib::MPI_Isend(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests[requests_position++]);
+    //requests.push_back(ep_lib::MPI_Request());
+    //ep_lib::MPI_Isend(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back());
+  }
   status.resize(requests.size());
 …
         recvTmp[recvRank][realRecvSize].first = globalLocalIndexGridDestSendToServer[recvIndexDst(idx)];
         recvTmp[recvRank][realRecvSize].second = recvWeightDst(idx);
-        tmpMask[globalLocalIndexGridDestSendToServer[recvIndexDst(idx)]] = true;
          ++realRecvSize;
+      }
 …
+}
+CATCH
 /*!
 …
 */
 const std::list<CGridTransformation::SendingIndexGridSourceMap>& CGridTransformation::getLocalIndexToSendFromGridSource() const
+TRY
+{
   return localIndexToSendFromGridSource_;
+}
+CATCH
 /*!
 …
 */
 const std::list<CGridTransformation::RecvIndexGridDestinationMap>& CGridTransformation::getLocalIndexToReceiveOnGridDest() const
+TRY
+{
   return localIndexToReceiveOnGridDest_;
+}
+CATCH
 /*!
 …
 */
 const std::list<size_t>& CGridTransformation::getNbLocalIndexToReceiveOnGridDest() const
+TRY
+{
   return nbLocalIndexOnGridDest_;
+}
+/*!
+  Local mask of data which will be received on the grid destination
+  \return local mask of data
+*/
+const std::list<std::vector<bool> >& CGridTransformation::getLocalMaskIndexOnGridDest() const
+{
+  return localMaskOnGridDest_;
+}
+}
+CATCH
+}

XIOS/dev/branch_openmp/src/transformation/grid_transformation.hpp

-                      r1328
+                      r1642
 #include <map>
 #include <vector>
-#include "mpi_std.hpp"
 #include "generic_algorithm_transformation.hpp"
 #include "transformation_enum.hpp"
 …
   const std::list<RecvIndexGridDestinationMap>& getLocalIndexToReceiveOnGridDest() const;
   const std::list<size_t>& getNbLocalIndexToReceiveOnGridDest() const;
-  const std::list<std::vector<bool> >& getLocalMaskIndexOnGridDest() const;
   CGrid* getGridSource() { return originalGridSource_; }
 …
   //! Number of local index of data to receive on grid destination
   std::list<size_t> nbLocalIndexOnGridDest_;
-  std::list<std::vector<bool> > localMaskOnGridDest_;
   bool dynamicalTransformation_;

XIOS/dev/branch_openmp/src/transformation/grid_transformation_factory_impl.hpp

-                      r1334
+                      r1642
   typedef std::map<ETranformationType, CreateTransformationCallBack> CallBackMap;
   static CallBackMap* transformationCreationCallBacks_;
-  #pragma omp threadprivate(transformationCreationCallBacks_)
   static bool registerTransformation(ETranformationType transType, CreateTransformationCallBack createFn);
   static bool unregisterTransformation(ETranformationType transType);
   static bool initializeTransformation_;
-  #pragma omp threadprivate(initializeTransformation_)
 };

XIOS/dev/branch_openmp/src/transformation/grid_transformation_selector.cpp

r1460	r1642
10	10	#include "grid.hpp"
11	11	#include "algo_types.hpp"
12		~~using namespace ep_lib;~~
13	12
14	13	namespace xios {
…	…
29	28	CAxisAlgorithmExtractDomain::registerTrans();
30	29	CAxisAlgorithmInterpolate::registerTrans();
	30	CAxisAlgorithmExtract::registerTrans();
31	31	CAxisAlgorithmInverse::registerTrans();
32	32	CAxisAlgorithmReduceDomain::registerTrans();
…	…
41	41	CDomainAlgorithmExpand::registerTrans();
42	42	CDomainAlgorithmReorder::registerTrans();
	43	CDomainAlgorithmExtract::registerTrans();
43	44	}
44	45
…	…
46	47	: gridSource_(source), gridDestination_(destination), isSameGrid_(false),
47	48	listAlgos_(), algoTypes_(), nbNormalAlgos_(0), nbSpecialAlgos_(0), auxInputs_()
	49	TRY
48	50	{
49	51	if (0 == source)
…	…
61	63	initializeTransformations(type);
62	64	}
	65	CATCH
63	66
64	67	/*!
…	…
69	72	*/
70	73	void CGridTransformationSelector::initializeTransformations(TransformationType type)
	74	TRY
71	75	{
72	76	// Initialize algorithms
…	…
99	103	}
100	104	}
	105	CATCH
101	106
102	107	CGridTransformationSelector::~CGridTransformationSelector()
	108	TRY
103	109	{
104	110	std::vector<CGenericAlgorithmTransformation*>::const_iterator itb = algoTransformation_.begin(), it,
…	…
106	112	for (it = itb; it != ite; ++it) delete (*it);
107	113	}
	114	CATCH
108	115
109	116	/*!
…	…
111	118	*/
112	119	void CGridTransformationSelector::updateElementPosition()
	120	TRY
113	121	{
114	122	int idxScalar = 0, idxAxis = 0, idxDomain = 0;
…	…
162	170	}
163	171	}
	172	CATCH
164	173
165	174	/*!
…	…
167	176	*/
168	177	void CGridTransformationSelector::initializeAlgorithms()
	178	TRY
169	179	{
170	180	updateElementPosition();
…	…
187	197	}
188	198	}
	199	CATCH
189	200
190	201	/*!
…	…
196	207	*/
197	208	void CGridTransformationSelector::initializeScalarAlgorithms(int scalarPositionInGrid)
	209	TRY
198	210	{
199	211	std::vector<CScalar*> scalarListDestP = gridDestination_->getScalars();
…	…
228	240	}
229	241	}
	242	CATCH
230	243
231	244	/*!
…	…
237	250	*/
238	251	void CGridTransformationSelector::initializeAxisAlgorithms(int axisPositionInGrid)
	252	TRY
239	253	{
240	254	std::vector<CAxis*> axisListDestP = gridDestination_->getAxis();
…	…
269	283	}
270	284	}
	285	CATCH
271	286
272	287	/*!
…	…
277	292	*/
278	293	void CGridTransformationSelector::initializeDomainAlgorithms(int domPositionInGrid)
	294	TRY
279	295	{
280	296	std::vector<CDomain*> domListDestP = gridDestination_->getDomains();
…	…
308	324	}
309	325	}
310
311		}
	326	}
	327	CATCH
312	328
313	329	/*!
…	…
320	336	*/
321	337	void CGridTransformationSelector::selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder, int algoType)
	338	TRY
322	339	{
323	340	updateElementPosition();
…	…
337	354	}
338	355	}
	356	CATCH
339	357
340	358	bool CGridTransformationSelector::isSpecialTransformation(ETranformationType transType)
	359	TRY
341	360	{
342	361	bool res = false;
…	…
352	371	return res;
353	372	}
354
355		}
	373	CATCH
	374
	375	}

XIOS/dev/branch_openmp/src/transformation/grid_transformation_selector.hpp

r1460	r1642
12	12	#include <map>
13	13	#include <vector>
14		~~#include "mpi_std.hpp"~~
15	14	#include "generic_algorithm_transformation.hpp"
16	15	#include "transformation_enum.hpp"

XIOS/dev/branch_openmp/src/transformation/scalar_algorithm_extract_axis.cpp

r1545	r1642
14	14	#include "grid_transformation_factory_impl.hpp"
15	15
16
	16	#include "reduction.hpp"
17	17
18	18	namespace xios {
…	…
26	26	std::map<int, int>& elementPositionInGridDst2AxisPosition,
27	27	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	28	TRY
28	29	{
29	30	std::vector<CScalar*> scalarListDestP = gridDst->getScalars();
…	…
36	37	return (new CScalarAlgorithmExtractAxis(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], extractAxis));
37	38	}
	39	CATCH
38	40
39	41	bool CScalarAlgorithmExtractAxis::registerTrans()
	42	TRY
40	43	{
41	44	CGridTransformationFactory<CScalar>::registerTransformation(TRANS_EXTRACT_AXIS_TO_SCALAR, create);
42	45	}
	46	CATCH
43	47
44	48	CScalarAlgorithmExtractAxis::CScalarAlgorithmExtractAxis(CScalar* scalarDestination, CAxis* axisSource, CExtractAxisToScalar* algo)
45	49	: CScalarAlgorithmTransformation(scalarDestination, axisSource),
46	50	reduction_(0)
	51	TRY
47	52	{
48	53	algo->checkValid(scalarDestination, axisSource);
49	54	StdString op = "extract";
50	55	pos_ = algo->position;
51		if(CReductionAlgorithm::ReductionOperations_ptr == 0)
52		{
53		CReductionAlgorithm::initReductionOperation();
54		}
55		reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations_ptr->at(op));
	56	reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]);
56	57	}
	58	CATCH
57	59
58	60	void CScalarAlgorithmExtractAxis::apply(const std::vector<std::pair<int,double> >& localIndex,
…	…
61	63	std::vector<bool>& flagInitial,
62	64	bool ignoreMissingValue, bool firstPass)
	65	TRY
63	66	{
64	67	reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass);
65	68	}
	69	CATCH
66	70
67	71	CScalarAlgorithmExtractAxis::~CScalarAlgorithmExtractAxis()
	72	TRY
68	73	{
69	74	if (0 != reduction_) delete reduction_;
70	75	}
	76	CATCH
71	77
72	78	void CScalarAlgorithmExtractAxis::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
	79	TRY
73	80	{
74	81	this->transformationMapping_.resize(1);
…	…
81	88	transWeight[0].push_back(1.0);
82	89	}
	90	CATCH
83	91
84	92	}

XIOS/dev/branch_openmp/src/transformation/scalar_algorithm_extract_axis.hpp

-                      r1339
+                      r1642
 #include "scalar_algorithm_transformation.hpp"
 #include "transformation.hpp"
-#include "reduction.hpp"
 namespace xios {
 …
   Extract a scalar from an axis
 */
 class CScalarAlgorithmExtractAxis : public CScalarAlgorithmTransformation, public CReductionAlgorithm
+class CScalarAlgorithmExtractAxis : public CScalarAlgorithmTransformation
+{
 public:

XIOS/dev/branch_openmp/src/transformation/scalar_algorithm_reduce_axis.cpp

r1545	r1642
13	13	#include "grid.hpp"
14	14	#include "grid_transformation_factory_impl.hpp"
	15	#include "reduction.hpp"
15	16
16
	17	#include "reduction.hpp"
17	18
18	19	namespace xios {
…	…
26	27	std::map<int, int>& elementPositionInGridDst2AxisPosition,
27	28	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	29	TRY
28	30	{
29	31	std::vector<CScalar*> scalarListDestP = gridDst->getScalars();
…	…
36	38	return (new CScalarAlgorithmReduceAxis(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], reduceAxis));
37	39	}
	40	CATCH
38	41
39	42	bool CScalarAlgorithmReduceAxis::registerTrans()
	43	TRY
40	44	{
41	45	CGridTransformationFactory<CScalar>::registerTransformation(TRANS_REDUCE_AXIS_TO_SCALAR, create);
42	46	}
	47	CATCH
43	48
44	49	CScalarAlgorithmReduceAxis::CScalarAlgorithmReduceAxis(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo)
45	50	: CScalarAlgorithmTransformation(scalarDestination, axisSource),
46	51	reduction_(0)
	52	TRY
47	53	{
48	54	if (algo->operation.isEmpty())
…	…
74	80	}
75	81
76		if(CReductionAlgorithm::ReductionOperations_ptr == 0)
77		{
78		CReductionAlgorithm::initReductionOperation();
79		}
80
81		if ((CReductionAlgorithm::ReductionOperations_ptr).end() == (CReductionAlgorithm::ReductionOperations_ptr).find(op))
	82	if (CReductionAlgorithm::ReductionOperations.end() == CReductionAlgorithm::ReductionOperations.find(op))
82	83	ERROR("CScalarAlgorithmReduceAxis::CScalarAlgorithmReduceAxis(CAxis* axisDestination, CAxis* axisSource, CReduceAxisToScalar* algo)",
83	84	<< "Operation '" << op << "' not found. Please make sure to use a supported one"
…	…
85	86	<< "Scalar destination " << scalarDestination->getId());
86	87
87		reduction_ = CReductionAlgorithm::createOperation(~~(*CReductionAlgorithm::ReductionOperations_ptr)~~[op]);
	88	reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]);
88	89	}
	90	CATCH
89	91
90	92	void CScalarAlgorithmReduceAxis::apply(const std::vector<std::pair<int,double> >& localIndex, const double* dataInput, CArray<double,1>& dataOut,
91	93	std::vector<bool>& flagInitial, bool ignoreMissingValue, bool firstPass)
	94	TRY
92	95	{
93	96	reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass);
94	97	}
	98	CATCH
95	99
96	100	void CScalarAlgorithmReduceAxis::updateData(CArray<double,1>& dataOut)
	101	TRY
97	102	{
98	103	reduction_->updateData(dataOut);
99	104	}
	105	CATCH
100	106
101	107	CScalarAlgorithmReduceAxis::~CScalarAlgorithmReduceAxis()
	108	TRY
102	109	{
103	110	if (0 != reduction_) delete reduction_;
104	111	}
	112	CATCH
105	113
106	114	void CScalarAlgorithmReduceAxis::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
	115	TRY
107	116	{
108	117	this->transformationMapping_.resize(1);
…	…
120	129	}
121	130	}
	131	CATCH
122	132
123	133	}

XIOS/dev/branch_openmp/src/transformation/scalar_algorithm_reduce_axis.hpp

-                      r1339
+                      r1642
 #include "scalar_algorithm_transformation.hpp"
 #include "transformation.hpp"
-#include "reduction.hpp"
 namespace xios {
 …
   Reducing an axis to a scalar
 */
 class CScalarAlgorithmReduceAxis : public CScalarAlgorithmTransformation, public CReductionAlgorithm
+class CScalarAlgorithmReduceAxis : public CScalarAlgorithmTransformation
+{
 public:

XIOS/dev/branch_openmp/src/transformation/scalar_algorithm_reduce_domain.cpp

r1545	r1642
14	14	#include "grid_transformation_factory_impl.hpp"
15	15
	16	#include "reduction.hpp"
16	17
17	18	namespace xios {
…	…
25	26	std::map<int, int>& elementPositionInGridDst2AxisPosition,
26	27	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	28	TRY
27	29	{
28	30	std::vector<CScalar*> scalarListDestP = gridDst->getScalars();
…	…
35	37	return (new CScalarAlgorithmReduceDomain(scalarListDestP[scalarDstIndex], domainListSrcP[domainSrcIndex], reduceDomain));
36	38	}
	39	CATCH
37	40
38	41	bool CScalarAlgorithmReduceDomain::registerTrans()
	42	TRY
39	43	{
40	44	CGridTransformationFactory<CScalar>::registerTransformation(TRANS_REDUCE_DOMAIN_TO_SCALAR, create);
41	45	}
	46	CATCH
42	47
43	48	CScalarAlgorithmReduceDomain::CScalarAlgorithmReduceDomain(CScalar* scalarDestination, CDomain* domainSource, CReduceDomainToScalar* algo)
44	49	: CScalarAlgorithmTransformation(scalarDestination, domainSource),
45	50	reduction_(0)
	51	TRY
46	52	{
47	53	algo->checkValid(scalarDestination, domainSource);
…	…
70	76	}
71	77
72		if(CReductionAlgorithm::ReductionOperations_ptr == 0)
73		{
74		CReductionAlgorithm::initReductionOperation();
75		}
76		if (CReductionAlgorithm::ReductionOperations_ptr->end() == CReductionAlgorithm::ReductionOperations_ptr->find(op))
	78	if (CReductionAlgorithm::ReductionOperations.end() == CReductionAlgorithm::ReductionOperations.find(op))
77	79	ERROR("CScalarAlgorithmReduceDomain::CScalarAlgorithmReduceDomain(CDomain* domainDestination, CDomain* domainSource, CReduceDomainToScalar* algo)",
78	80	<< "Operation '" << op << "' not found. Please make sure to use a supported one"
…	…
80	82	<< "Scalar destination " << scalarDestination->getId());
81	83
82		reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations~~_ptr->at(op)~~);
	84	reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]);
83	85	local = algo->local ;
84	86	}
	87	CATCH
85	88
86	89	void CScalarAlgorithmReduceDomain::apply(const std::vector<std::pair<int,double> >& localIndex,
…	…
89	92	std::vector<bool>& flagInitial,
90	93	bool ignoreMissingValue, bool firstPass)
	94	TRY
91	95	{
92	96	reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass);
93	97	}
	98	CATCH
94	99
95	100	void CScalarAlgorithmReduceDomain::updateData(CArray<double,1>& dataOut)
	101	TRY
96	102	{
97	103	reduction_->updateData(dataOut);
98	104	}
	105	CATCH
99	106
100	107	CScalarAlgorithmReduceDomain::~CScalarAlgorithmReduceDomain()
	108	TRY
101	109	{
102	110	if (0 != reduction_) delete reduction_;
103	111	}
	112	CATCH
104	113
105	114	void CScalarAlgorithmReduceDomain::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
	115	TRY
106	116	{
107	117	this->transformationMapping_.resize(1);
…	…
140	150
141	151	}
	152	CATCH
142	153
143	154	}

XIOS/dev/branch_openmp/src/transformation/scalar_algorithm_reduce_domain.hpp

-                      r1460
+                      r1642
 #include "scalar_algorithm_transformation.hpp"
 #include "transformation.hpp"
-#include "reduction.hpp"
 namespace xios {
 …
   Reducing an DOMAIN to a scalar
 */
 class CScalarAlgorithmReduceDomain : public CScalarAlgorithmTransformation, public CReductionAlgorithm
+class CScalarAlgorithmReduceDomain : public CScalarAlgorithmTransformation
+{
 public:

XIOS/dev/branch_openmp/src/transformation/scalar_algorithm_reduce_scalar.cpp

r1545	r1642
9	9	#include "grid.hpp"
10	10	#include "grid_transformation_factory_impl.hpp"
11
	11	#include "reduction.hpp"
12	12
13	13
…	…
22	22	std::map<int, int>& elementPositionInGridDst2AxisPosition,
23	23	std::map<int, int>& elementPositionInGridDst2DomainPosition)
	24	TRY
24	25	{
25	26	std::vector<CScalar*> scalarListDestP = gridDst->getScalars();
…	…
32	33	return (new CScalarAlgorithmReduceScalar(scalarListDestP[scalarDstIndex], scalarListSrcP[scalarSrcIndex], reduceScalar));
33	34	}
	35	CATCH
34	36
35	37	bool CScalarAlgorithmReduceScalar::registerTrans()
	38	TRY
36	39	{
37	40	CGridTransformationFactory<CScalar>::registerTransformation(TRANS_REDUCE_SCALAR_TO_SCALAR, create);
38	41	}
	42	CATCH
39	43
40	44	CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CScalar* scalarDestination, CScalar* scalarSource, CReduceScalarToScalar* algo)
41	45	: CScalarAlgorithmTransformation(scalarDestination, scalarSource),
42	46	reduction_(0)
	47	TRY
43	48	{
44	49	eliminateRedondantSrc_= false ;
…	…
70	75
71	76	}
72
73		~~if(CReductionAlgorithm::ReductionOperations_ptr == 0)~~
74		{
75		~~CReductionAlgorithm::initReductionOperation();~~
76		}
77	77
78		if (CReductionAlgorithm::ReductionOperations~~_ptr->end() == CReductionAlgorithm::ReductionOperations_ptr->~~find(op))
	78	if (CReductionAlgorithm::ReductionOperations.end() == CReductionAlgorithm::ReductionOperations.find(op))
79	79	ERROR("CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CScalar* scalarDestination, CScalar* scalarSource, CReduceScalarToScalar* algo)",
80	80	<< "Operation '" << op << "' not found. Please make sure to use a supported one"
…	…
82	82	<< "Scalar destination " << scalarDestination->getId());
83	83
84		reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations~~_ptr->at(op)~~);
	84	reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]);
85	85	}
	86	CATCH
86	87
87	88	void CScalarAlgorithmReduceScalar::apply(const std::vector<std::pair<int,double> >& localIndex, const double* dataInput, CArray<double,1>& dataOut,
88	89	std::vector<bool>& flagInitial, bool ignoreMissingValue, bool firstPass)
	90	TRY
89	91	{
90	92	reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass);
91	93	}
	94	CATCH
92	95
93	96	void CScalarAlgorithmReduceScalar::updateData(CArray<double,1>& dataOut)
	97	TRY
94	98	{
95	99	reduction_->updateData(dataOut);
96	100	}
	101	CATCH
97	102
98	103	CScalarAlgorithmReduceScalar::~CScalarAlgorithmReduceScalar()
	104	TRY
99	105	{
100	106	if (0 != reduction_) delete reduction_;
101	107	}
	108	CATCH
102	109
103	110	void CScalarAlgorithmReduceScalar::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
	111	TRY
104	112	{
105	113	this->transformationMapping_.resize(1);
…	…
113	121
114	122	}
	123	CATCH
115	124
116	125	}

XIOS/dev/branch_openmp/src/transformation/scalar_algorithm_reduce_scalar.hpp

-                      r1460
+                      r1642
 #include "scalar_algorithm_transformation.hpp"
 #include "transformation.hpp"
-#include "reduction.hpp"
 namespace xios {
 …
   Reducing an scalar to a scalar
 */
 class CScalarAlgorithmReduceScalar : public CScalarAlgorithmTransformation, public CReductionAlgorithm
+class CScalarAlgorithmReduceScalar : public CScalarAlgorithmTransformation
+{
 public:

XIOS/dev/branch_openmp/src/transformation/scalar_algorithm_transformation.cpp

r1460	r1642
57	57	int elementSourceType,
58	58	CClientClientDHTInt::Index2VectorInfoTypeMap& globalIndexElementSourceOnProc)
	59	TRY
59	60	{
60	61	CContext* context = CContext::getCurrent();
…	…
121	122	}
122	123	}
123
	124	CATCH
124	125	}

Context Navigation

Legend:

Download in other formats: