CDPP / AMDA_Kernel

Blame view

src/ExternLib/mexvex_els_decode/MexVexElsDecode.hh 3.36 KB
Edit Raw Normal View History
35de3ffa   Elena.Budnik   mexvex_els 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
/*
 * MexVexElsDecode.hh
 *
 *  Created on: Oct 13, 2016
 *      Author: elena / benjamin
 */

#ifndef MEXVEXELSDECODE_HH_
#define MEXVEXELSDECODE_HH_

#include "Parameter.hh"
#include "ParamData.hh"
#include "DataTypeMath.hh"
#include "Operation.hh"

namespace AMDA {
namespace Parameters {
namespace MexVexElsDecode {

/**
 * @class MexVexElsDecode
 * @brief 
 * @details This class implement the interface Operation.
 */

template <typename TParamData> 
class MexVexElsDecode : public Operation {
	
typedef typename TParamData::ElementType ElemType;

public:
	/**
	 * @brief Constructor.
	 * @details Create the ParamData type of the input ParamData.
	 */
	MexVexElsDecode(Process& pProcess, TParamData& paramInput, std::string energyTable)
	: Operation(pProcess),
	  _paramInput(paramInput),
	  _paramOutput(new TParamData()),
	  _energyTable(energyTable){
	  _paramDataOutput=_paramOutput;
	}

	virtual ~MexVexElsDecode() {
		
	}

	/**
	 * @overload Operation::write(ParamDataIndexInfo &pParamDataIndexInfo)
	 */
  
	void write(ParamDataIndexInfo &pParamDataIndexInfo) {
	  
		ParameterSPtr crtParam = _process.getParameterManager().getParameter(_energyTable);
		ParamData* lModeParamInput = crtParam->getParamData(&_process).get();
		for (unsigned int _index = pParamDataIndexInfo._startIndex ;
			_index < pParamDataIndexInfo._startIndex + pParamDataIndexInfo._nbDataToProcess;
			++_index)
		{
			double crtTime = _paramInput.getTime(_index);
			ElemType inputElt = _paramInput.get(_index);
		
			int mode = (dynamic_cast<ParamDataScalaireShort*>(lModeParamInput))->get(_index);
	     
			if (mode == 1) {
				for (int i = 0; i < 4; ++i){			       
					_paramOutput->pushTime(crtTime+i);
					pushDataForMode1 (inputElt, i);				 
				}
			}
			else if (mode == 0 || mode == 2)			
			{
				_paramOutput->pushTime(crtTime);
				_paramOutput->getDataList().push_back(inputElt);
			}
		}		
	}
3a91e5e3   Benjamin Renard   Fix mex/vex els p... 
78
35de3ffa   Elena.Budnik   mexvex_els 
79
80
81
82
 
	template<typename Type>
	void pushDataForMode1(Type& elt, int index) {
		_paramOutput->getDataList().push_back(elt);
	}
3a91e5e3   Benjamin Renard   Fix mex/vex els p... 
83
35de3ffa   Elena.Budnik   mexvex_els 
84
85
86
87
 
	template<typename Type>
	void pushDataForMode1(std::vector<Type>& elt, int index) {
		typename std::vector<Type>::const_iterator first = elt.begin() + 31 * index;
		typename std::vector<Type>::const_iterator last = elt.begin() + 31 * (index + 1);
3a91e5e3   Benjamin Renard   Fix mex/vex els p... 
88
89
90
91
92
93
94
95
96
 
		std::vector<Type> splitVec;
		splitVec.resize(128, std::nan(""));

		int i = 0;
		for (typename std::vector<Type>::const_iterator it = first; it != last; ++it) {
			splitVec[i] = (*it);
			++i;
		}
35de3ffa   Elena.Budnik   mexvex_els 
97
98
99
100
101
 
		_paramOutput->getDataList().push_back(splitVec);
	}		
	
	template<typename Type>  
	void pushDataForMode1(Tab2DData<Type>& elt, int index) {
35de3ffa   Elena.Budnik   mexvex_els 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
		Tab2DData<Type> newElt(elt.getDim1Size(),32); 
		for(int i = 0; i < elt.getDim1Size(); ++i) {                        			
			std::vector<Type> eltVector = elt[i].toVector();
			typename std::vector<Type>::const_iterator first = eltVector.begin() + 31 * index;
			typename std::vector<Type>::const_iterator last = eltVector.begin() + 31 * (index + 1);
			std::vector<Type> splitVec(first, last);
			newElt[i] = splitVec;
		}                
		_paramOutput->getDataList().push_back(newElt);
	}
  
private:
	/**<
	 * @brief It is the channel of data derived
	 */
	TParamData &_paramInput;

	/**<
	 * @brief It is the channel of the data derived
	 */
	TParamData *_paramOutput;
	
	std::string _energyTable; 
};  

} /* namespace MexVexElsDecode */
} /* namespace Parameters */
} /* namespace AMDA */
#endif /* MEXVEXELSDECODE_HH_ */