Skip to content
Snippets Groups Projects
MatData.cpp 36.9 KiB
Newer Older
  • Learn to ignore specific revisions
  • Radim Vavřík's avatar
    Radim Vavřík committed
    		{
    			std::istringstream iss(value);
    			std::vector<double> tmp;
    			for(int i=0; i<nColumns; i++)
    			{
    				getline(iss, mdv, ';');
    				if(i>0) // First token is Time, not station id
    				{
    					tmp.push_back(atof(mdv.c_str()));
    				}
    			}
    			m_measuredDischargeVolumes.push_back(tmp);
    		}
    		measuredDischargeVolumesFile.close();
    	}
    
    	void MatData::loadPrecipitationsFromCsv()
    	{
    		std::ifstream precipitationsFile(m_precipitationsCsvFilePath.c_str());
    		std::string value, firstLine, precipitation;
    		int nColumns = 0;
    
    		// Gets number of columns
    		// First line is header consisting of string "Time" and Station Ids
    		if(getline(precipitationsFile, firstLine))
    		{
    			std::istringstream iss(firstLine);
    			while(getline(iss, value, ';'))
    			{
    				if(value != "Time")
    				{
    					m_precStationIds.push_back(atoi(value.c_str()));
    				}
    				nColumns++;
    			}
    		}
    
    		// Parse data
    		while(getline(precipitationsFile, value))
    		{
    			std::istringstream iss(value);
    			std::pair<time_t ,std::vector<double>> tmp;
    			for(int i=0; i<nColumns; i++)
    			{
    				getline(iss, precipitation, ';');
    				if(i==0) // First token is Time, not station id
    				{
    					tm dateTime;
    					int day, month, year, hour, minute;
    					//14.5.2010 6:00
    					SSCANF(precipitation.c_str(), "%d-%d-%d %d:%d", &year, &month, &day, &hour, &minute);
    
    					dateTime.tm_year = year - 1900;
    					dateTime.tm_mon = month - 1;
    					dateTime.tm_mday = day;
    					dateTime.tm_hour = hour;
    					dateTime.tm_min = minute;
    					dateTime.tm_sec = 0;
    
    					tmp.first = mktime(&dateTime);
    				}
    				else
    				{
    					tmp.second.push_back(std::atof(precipitation.c_str()));
    				}
    			}
    			m_precipitations.push_back(tmp);
    		}
    		precipitationsFile.close();
    	}
    
    	void MatData::getMeasuredHydrographs()
    	{
    		int nH = 0;
    		int rows = (int )m_measuredDischargeVolumes.size();
    
    		if(rows > 0)
    		{
    			// Get number of columns
    			nH = (int )m_measuredDischargeVolumes[0].size();
    		}
    
    		for(int i = 0; i < nH; i++)
    		{
    			bool noValue = true;
    
    			for(size_t j = 0; j < m_measuredDischargeVolumes[i].size(); j++ )
    			{
    				if(m_measuredDischargeVolumes[j][i] > -999)
    				{
    					noValue = false;
    					break;
    				}
    			}
    
    			if(noValue)	continue;
    			
    			std::vector<double> tmp;
    			for(int j = 0; j < rows; j++)
    			{
    				if(m_measuredDischargeVolumes[j][i] > -999)
    				{
    					// int k = j * 60 / m_minuteStep + 1; // Don't understand
    					
    					tmp.push_back(m_measuredDischargeVolumes[j][i]);
    				}
    				else
    				{
    					tmp.push_back(0);
    				}
    			}	
    			m_measuredHydrographsQ.push_back(tmp);
    
    			m_measureStations.push_back(findStation(m_riverStations, m_mdvStationIds[i]));
    		}
    	}
    
    	std::vector<std::shared_ptr<Station>>& MatData::getSourceStations()
    	{
    		return MatData::m_sourceStations;
    	}
    
    	void MatData::setSourceStations(const std::vector<std::shared_ptr<Station>>& sourceStations)
    	{
    		m_sourceStations = sourceStations;
    	}
    
    	const int& MatData::getBasinId()
    	{
    		return m_basinId;
    	}
    	
    	std::string MatData::intToString(const int& number)
    	{
    		std::ostringstream os;
    		os << number;
    		return os.str();
    	}
    
    	std::string MatData::printDateTime(const time_t& dateTime)
    	{
    		std::ostringstream str;
    		struct tm * timeInfo;
    		char buffer[6];
    		timeInfo = localtime(&dateTime);
    		strftime(buffer, 6, "%H:%M", timeInfo);
    		std::string month = intToString(timeInfo->tm_mon + 1);
    		if(month.length() == 1)
    		{
    			month = "0" + month;
    		}
    
    		str << timeInfo->tm_year + 1900 << "-" << month << "-" << timeInfo->tm_mday << " " 
    			<< buffer;
    
    		return str.str();
    	}
    
    	std::shared_ptr<Station> MatData::findStation(std::vector<std::shared_ptr<Station>>& stations, int& id)
    	{
    		std::shared_ptr<Station> station;
    		for(size_t i = 0; i < stations.size(); i++)
    		{
    			if(stations[i].get()->getId() == id)
    				station = stations[i];
    		}
    
    		return station;
    	}
    
    	Options& MatData::getOptions()
    	{
    		return this->m_options;
    	}
    
    	void MatData::setOptions(Options options)
    	{
    		this->m_options = options;
    	}
    
    	std::vector<std::vector<double>> MatData::getMeasuredHydrographsQ()
    	{
    		return this->m_measuredHydrographsQ;
    	}
    
    	std::vector<std::shared_ptr<Station>>& MatData::getMeasureStations()
    	{
    		return this->m_measureStations;
    	}
    
    	std::vector<std::shared_ptr<Station>>& MatData::getRiverStations()
    	{
    		return this->m_riverStations;
    	}
    
    	std::vector<std::shared_ptr<Channel>>& MatData::getChannels()
    	{
    		return this->m_channels;
    	}
    
    	std::shared_ptr<Channel> MatData::getChannelById(int id)
    	{
    		std::shared_ptr<Channel> res;
    		for (size_t i = 0; i < this->m_channels.size(); i++)
    		{
    			if(m_channels[i]->getId() == id)
    			{
    				res = m_channels[i];
    				break;
    			}
    		}
    		return res;
    	}
    
    	std::shared_ptr<Subbasin> MatData::getSubbasinById(int id)
    	{
    		std::shared_ptr<Subbasin> res;
    		for (size_t i = 0; i < this->m_subbasins.size(); i++)
    		{
    			if(m_subbasins[i]->getId() == id)
    			{
    				res = m_subbasins[i];
    				break;
    			}
    		}
    		return res;
    	}
    
    	std::vector<std::shared_ptr<Subbasin>>& MatData::getSubbasins()
    	{
    		return m_subbasins;
    	}
    	
    	void MatData::clearResults()
    	{
    		for (size_t i = 0; i < m_channels.size(); i++)
    		{
    			m_channels[i]->getHydrograph().clear();
    		}
    	}
    
    	precipitationsVector MatData::getPrecipitations()
    	{
    		return m_precipitations;
    	}
    
    	void MatData::setPrecipitations(const precipitationsVector precipitations)
    	{
    		m_precipitations = precipitations;
    	}
    
    	int MatData::checkFWL()
    	{
    		int FWL = -1;
    		if(!m_simulationDone)
    		{
    			CLOG(FATAL,"model") << "Cannot check FWL exceeding, simulation is not done!";	
    		}
    		for (size_t i = 0; i < m_measureStations.size(); i++)
    		{
    			std::vector<double> qOut = m_channels[m_measureStations[i]->getChannelIndex()]->getHydrograph().getQOut();
    			double spa1 = m_measureStations[i]->getSpa1();
    			double spa2 = m_measureStations[i]->getSpa2();
    			double spa3 = m_measureStations[i]->getSpa3();
    			int basinFWL = -1;
    
    			for (size_t j = 0; j < qOut.size(); j++)
    			{
    				int channelFWL = -1;
    				
    				if(qOut[j] < spa1)
    					channelFWL = 0;
    				else if(qOut[j] < spa2)
    					channelFWL = 1;
    				else if(qOut[j] < spa3)
    					channelFWL = 2;
    				else
    					channelFWL = 3;
    
    				if(channelFWL > basinFWL)
    					basinFWL = channelFWL;
    			}
    
    			if(basinFWL > FWL)
    				FWL = basinFWL;
    		}
    
    		return FWL;
    	}
    }