CDPP / AMDA_Kernel

Blame view

src/ParamOutputImpl/DataMining/DataMiningValidInterval.cc 3.76 KB
Edit Raw Normal View History
fbe3c2bb   Benjamin Renard   First commit 
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
 
/*
 * DataMiningValidInterval.cc
 *
 *  Created on: 3 oct. 2013
 *      Author: CS
 */

#include "DataMiningValidInterval.hh"

// TimeTable
#include "TimeTableCatalogUtil.hh"


using namespace TimeTableCatalog;

namespace AMDA {
	namespace ParamOutputImpl {
		namespace DataMining {

			log4cxx::LoggerPtr DataMiningValidInterval::_logger(log4cxx::Logger::getLogger("AMDA-Kernel.DataMiningValidInterval"));

			DataMiningValidInterval::DataMiningValidInterval(std::string pPrefixTTFileName, LogicalData pDataToMatch, ParamOutputDataMining* pParamOutputDataMining) :
				DataMiningType(pParamOutputDataMining, pPrefixTTFileName),
				_valCurrent(false),
				_beginTimeInterval(0),
				_endTimeInterval(0),
				_dataToMatch(pDataToMatch){
			}

			void DataMiningValidInterval::setTimeInterval(const TimeInterval& pTimeInterval) {
				DataMiningType::setTimeInterval(pTimeInterval);
				_valCurrent = false;
				_beginTimeInterval = 0;
				_endTimeInterval = 0;
			}

			void DataMiningValidInterval::checkTimeIntervalBounds() {
				// If the begin time of the interval is the same value as the start time research,
				// We must not subtract samplingTime / 2 to the _beginTimeInterval (boundary value)
				// TODO prendre en compte une liste d'intervalle de temps
				// et non plus une date de départ suivi d'un délai.
				if (_beginTimeInterval != _inputTimeInterval._startTime) {
					_beginTimeInterval = _beginTimeInterval - (_samplingTime / 2);
				}

				if(_endTimeInterval != _inputTimeInterval._stopTime) {
					_endTimeInterval = _endTimeInterval + (_samplingTime / 2);
				} else {
					// Nothing to do we have reached the end time research so we must not
					// add samplingTime / 2 to the _endTimeInterval (boundary value).
				}
			}

			void DataMiningValidInterval::createInterval(ParamDataLogicalData* pParamData, ParamDataIndexInfo pParamDataIndexInfo) {
fbe3c2bb   Benjamin Renard   First commit 
55
 
				for (unsigned int index = pParamDataIndexInfo._startIndex; index < pParamDataIndexInfo._nbDataToProcess + pParamDataIndexInfo._startIndex; ++index) {
c6a67968   Benjamin Renard   Fix some violatio... 
56
57
 
					double lTime = pParamData->getTime(index);
					double lData = pParamData->get(index);
fbe3c2bb   Benjamin Renard   First commit 
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 

					if(_logger->isDebugEnabled()) {
						std::stringstream date;
						writeISOTime(lTime, TimeTable::YYYYMMDDThhmmss, date);

#if 0	// Ne sert à rien !
						std::string lValue;
						if(lData == True) {
							lValue = "True";
						} else if (pParamData->get(index) == False) {
							lValue = "False";
						} else {
							lValue = "Nan";
						}
#endif
//						LOG4CXX_DEBUG(_logger,"Time and Value: " + date.str() + ", " + lValue);
					}

					// Found beginning of a time interval
					if(!_valCurrent && lData == _dataToMatch) {
						_valCurrent = true;
						_beginTimeInterval = lTime;
						_endTimeInterval = lTime;
					}
					// Increase the end of the time interval
					else if(_valCurrent && lData == _dataToMatch) {
						_endTimeInterval = lTime;
					}
					// Found ending of the time interval
					else if(_valCurrent && lData != _dataToMatch) {
						_valCurrent = false;

						// Check time interval bounds.
						checkTimeIntervalBounds();

//						LOG4CXX_DEBUG(_logger,"resultat min sampling:"<<_paramOutputDataMining->getParameter()->getParamData(this)->getMinSampling());
						_timeTable->addInterval(TimeInterval(_beginTimeInterval, _endTimeInterval));
					}
				}
			}

			void DataMiningValidInterval::finalize() {
				// If the last interval is not closed, so close it.
				if(_valCurrent) {
					_timeTable->addInterval(TimeInterval(_beginTimeInterval - (_samplingTime / 2), _inputTimeInterval._stopTime));
				}
			}

			void DataMiningValidInterval::fillInformation(TimeTable::TIME_FORMAT pTimeFormat, std::string pFileName, int pIndex) {
				finalize();

				DataMiningType::fillInformation(pTimeFormat, pFileName, pIndex);
			}

		} // DataMining
	} // ParamOutputImpl
} // AMDA