//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=---=-=-=-=-=-=-=-=-=-=-=-=-
// This function prints a chan file for assimilation into the chi analysis,
// but in this cases uses a discharge rather than a drainage area
//
// the file format is
// channel_number node_index node_on_reciever row column flow_dist elevation drainage_area
//
// SMM 07/05/2015
//
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
void LSDIndexChannelTree::print_LSDChannels_for_chi_network_ingestion(LSDFlowInfo& FlowInfo,
LSDRaster& Elevation_Raster, LSDRaster& FlowDistance, string fname,
LSDRaster& Discharge)
{
if (organization_switch != 1)
{
cout << "LSDIndexChannelTree you can't run LSDIndexChannelTree::retrieve_LSDChannels_from_tree" << endl;
cout << "with this channel organization, organization switch: " << organization_switch << endl;
exit(EXIT_FAILURE);
}
// open the outfile
ofstream channelfile_out;
channelfile_out.open(fname.c_str());
channelfile_out.precision(10);
float m_over_n = 0.5;
float A_0 = 1;
// get the vector of channels
vector<LSDChannel> vector_of_channels = retrieve_LSDChannels_from_tree(m_over_n, A_0, FlowInfo,Elevation_Raster);
int n_channels = vector_of_channels.size();
int n_nodes_in_channel;
int node,row,col;
float elev,chi,drain_area,flow_dist,this_discharge;
// first print out some data about the dem
channelfile_out << get_NRows() << endl;
channelfile_out << get_NCols() << endl;
channelfile_out << get_XMinimum() << endl;
channelfile_out << get_YMinimum() << endl;
channelfile_out << get_DataResolution() << endl;
channelfile_out << get_NoDataValue() << endl;
//loop through the channels
for (int i = 0; i< n_channels; i++)
{
// get the number of nodes in the channel
n_nodes_in_channel =IndexChannelVector[i].get_n_nodes_in_channel();
// now loop through the channel, printing out the data.
for(int ch_node= 0; ch_node<n_nodes_in_channel; ch_node++)
{
IndexChannelVector[i].get_node_row_col_in_channel(ch_node, node, row, col);
vector_of_channels[i].retrieve_node_information(ch_node, elev, chi, drain_area);
flow_dist = FlowDistance.get_data_element(row,col);
this_discharge = Discharge.get_data_element(row,col);
// print data to file
channelfile_out << i << " " << receiver_channel[i] << " " << node_on_receiver_channel[i] << " "
<< node << " " << row << " " << col << " " << flow_dist << " "
<< " " << elev << " " << this_discharge << endl;
}
}
channelfile_out.close();
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// Calculate w, a hyrdological index, used in the factor of safety equation.
// Call with the ratio of recharge to transmissivity.
// SWDG 13/6/16
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
LSDSoilHydroRaster LSDSoilHydroRaster::Calculate_w(LSDRaster& Slope, LSDRaster& DrainageArea){
Array2D<float> w(NRows, NCols, NoDataValue);
for (int i = 1; i < NRows - 1; ++i){
for (int j = 1; j < NCols - 1; ++j){
if (RasterData[i][j] != NoDataValue){
float value = RasterData[i][j] * (DrainageArea.get_data_element(i,j)/sin(Slope.get_data_element(i,j)));
if (value < 1.0){
w[i][j] = value;
}
else{
w[i][j] = 1.0;
}
}
}
}
LSDSoilHydroRaster output(NRows,NCols,XMinimum,YMinimum,DataResolution,NoDataValue,w,GeoReferencingStrings);
return output;
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
// This is an incredibly rudimentary function used to modify landslide raster
// It takes a few rasters from the
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void LSDSoilHydroRaster::NaiveLandslide(LSDRaster& FilledElevation, int initiationPixels,
int MinPixels, float landslide_thickness)
{
// Get a flow info object
// set no flux boundary conditions
vector<string> boundary_conditions(4);
boundary_conditions[0] = "No";
boundary_conditions[1] = "no flux";
boundary_conditions[2] = "no flux";
boundary_conditions[3] = "No flux";
// some values from the rasters
float local_elev;
float local_mask;
// get a flow info object
LSDFlowInfo FlowInfo(boundary_conditions,FilledElevation);
// get the contributing pixels
LSDIndexRaster ContributingPixels = FlowInfo.write_NContributingNodes_to_LSDIndexRaster();
vector<int> sources = FlowInfo.get_sources_index_threshold(ContributingPixels, initiationPixels);
// get a value vector for the landslides
vector<float> landslide_thicknesses;
for (int i = 0; i< int(sources.size()); i++)
{
landslide_thicknesses.push_back(landslide_thickness);
}
// get the mask
LSDRaster Mask = FlowInfo.get_upslope_node_mask(sources,landslide_thicknesses);
// now set all points that have elevation data but not landslide data to
// the value of the landslide thickness, removing data that is below the minium
// pixel area
for (int row = 0; row<NRows; row++)
{
for (int col = 0; col<NCols; col++)
{
local_elev = FilledElevation.get_data_element(row,col);
local_mask = Mask.get_data_element(row,col);
RasterData[row][col] = local_mask;
// Turn nodata points into 0s
if( local_mask == NoDataValue)
{
RasterData[row][col] = 0.0;
}
// remove data where there is no topographic information
if( local_elev == NoDataValue)
{
RasterData[row][col] = NoDataValue;
}
}
}
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=---=-=-=-=-=-=-=-=-=-=-=-=-
// Same as above but also reports the discharge
//
// SMM 06/05/2015
//
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void LSDIndexChannelTree::convert_chan_file_for_ArcMap_ingestion(string fname, LSDRaster& DrainageArea, LSDRaster& Discharge)
{
// open the outfile
ifstream channelfile_in;
channelfile_in.open(fname.c_str());
unsigned dot = fname.find_last_of(".");
string prefix = fname.substr(0,dot);
//string suffix = str.substr(dot);
string insert = "_for_Arc.csv";
string outfname = prefix+insert;
cout << "the Arc channel filename is: " << outfname << endl;
ofstream ArcChan_out;
ArcChan_out.open(outfname.c_str());
ArcChan_out.precision(10);
// print the first line of the arcchan. This is going to be comma seperated!
ArcChan_out << "id,x,y,channel,reciever_channel,node_on_reciever_channel,node,row,col,flow_distance_m,elevation_m,drainage_area_m2,discharge_m2_times_precipunits" << endl;
// now go throught the file, collecting the data
int id,ch,rc,norc,n,r,c;
float fd,elev,da;
float x,y;
float xll;
float yll;
float datares;
float ndv;
int nrows;
int ncols;
float this_discharge;
float this_da;
// read in the first lines with DEM information
channelfile_in >> nrows >> ncols >> xll >> yll >> datares >> ndv;
id = 0;
// now loop through the file, calculating x and y locations as you go
while(channelfile_in >> ch >> rc >> norc >> n >> r >> c >> fd >> elev >> da)
{
id++;
x = xll + float(c)*datares + 0.5*datares;
y = yll + float(nrows-r)*datares - 0.5*datares; // this is because the DEM starts from the top corner
this_discharge = Discharge.get_data_element(r,c);
this_da = DrainageArea.get_data_element(r,c);
ArcChan_out << id << "," << x << "," << y << "," << ch << "," << rc
<< "," << norc << "," << n << "," << r << "," << c << ","
<< fd << "," << elev << "," << this_da << "," << this_discharge << endl;
}
channelfile_in.close();
ArcChan_out.close();
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
// Create function that takes the dimensions and georeferencing of a raster
// but then sets all data to value, setting the NoDataValues to
// the NoData of the raster
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void LSDSoilHydroRaster::create(LSDRaster& OtherRaster, float value)
{
NRows = OtherRaster.get_NRows();
NCols = OtherRaster.get_NCols();
XMinimum = OtherRaster.get_XMinimum();
YMinimum = OtherRaster.get_YMinimum();
DataResolution = OtherRaster.get_DataResolution();
NoDataValue = OtherRaster.get_NoDataValue();
GeoReferencingStrings = OtherRaster.get_GeoReferencingStrings();
// set the raster data to be a certain value
Array2D<float> data(NRows,NCols,NoDataValue);
for (int row = 0; row <NRows; row++)
{
for (int col = 0; col<NCols; col++)
{
if (OtherRaster.get_data_element(row,col) != NoDataValue)
{
data[row][col] = value;
//cout << value << endl;
}
}
}
RasterData = data.copy();
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
// This prints a chi map to csv with an area threshold in m^2
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void LSDChiTools::chi_map_to_csv(LSDFlowInfo& FlowInfo, string chi_map_fname,
float A_0, float m_over_n, float area_threshold)
{
ofstream chi_map_csv_out;
chi_map_csv_out.open(chi_map_fname.c_str());
chi_map_csv_out.precision(9);
float chi_coord;
double latitude,longitude;
LSDCoordinateConverterLLandUTM Converter;
chi_map_csv_out << "latitude,longitude,chi" << endl;
LSDRaster Chi = FlowInfo.get_upslope_chi_from_all_baselevel_nodes(m_over_n, A_0, area_threshold);
float NDV = Chi.get_NoDataValue();
for(int row = 0; row<NRows; row++)
{
for(int col = 0; col<NCols; col++)
{
chi_coord = Chi.get_data_element(row,col);
if (chi_coord != NDV)
{
get_lat_and_long_locations(row, col, latitude, longitude, Converter);
chi_map_csv_out << latitude << "," << longitude << "," << chi_coord << endl;
}
}
}
chi_map_csv_out.close();
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// Calculate the the sinmap Stability Index (SI).
// This is a wrapper around a lightly modified port of the original sinmap 2.0 implementation.
// call with any SoilHydroRaster, it's values are used for identification of NoDataValues.
//
// SWDG 15/6/16
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
LSDSoilHydroRaster LSDSoilHydroRaster::Calculate_sinmap_SI(LSDRaster Slope, LSDRaster DrainageArea, LSDSoilHydroRaster lo_C, LSDSoilHydroRaster hi_C, LSDSoilHydroRaster lo_phi, LSDSoilHydroRaster hi_phi, LSDSoilHydroRaster lo_RoverT, LSDSoilHydroRaster hi_RoverT, LSDSoilHydroRaster lo_r, LSDSoilHydroRaster hi_r, LSDSoilHydroRaster lo_FS, LSDSoilHydroRaster hi_FS){
Array2D<float> SI(NRows, NCols, NoDataValue);
for (int i = 1; i < NRows - 1; ++i){
for (int j = 1; j < NCols - 1; ++j){
if (RasterData[i][j] != NoDataValue){
SI[i][j] = StabilityIndex(Slope.get_data_element(i, j), DrainageArea.get_data_element(i, j), lo_C.get_data_element(i, j), hi_C.get_data_element(i, j), lo_phi.get_data_element(i, j), hi_phi.get_data_element(i, j), lo_RoverT.get_data_element(i, j), hi_RoverT.get_data_element(i, j), lo_r.get_data_element(i, j), hi_r.get_data_element(i, j), lo_FS.get_data_element(i, j), hi_FS.get_data_element(i, j));
}
}
}
LSDSoilHydroRaster output(NRows,NCols,XMinimum,YMinimum,DataResolution,NoDataValue,SI,GeoReferencingStrings);
return output;
}
void LSDSoilHydroRaster::create(LSDRaster& DEM, LSDRaster& OtherRaster, int min_max)
{
NRows = OtherRaster.get_NRows();
NCols = OtherRaster.get_NCols();
XMinimum = OtherRaster.get_XMinimum();
YMinimum = OtherRaster.get_YMinimum();
DataResolution = OtherRaster.get_DataResolution();
NoDataValue = OtherRaster.get_NoDataValue();
GeoReferencingStrings = OtherRaster.get_GeoReferencingStrings();
// set the raster data to be a certain value
Array2D<float> data(NRows,NCols,NoDataValue);
float min_max_val = NoDataValue;
if (min_max == 0){
// get the minimum value of OtherRaster
Array2D<float> tmp = OtherRaster.get_RasterData();
min_max_val = Get_Minimum(tmp, NoDataValue);
}
else if (min_max == 1){
// get the maximum value of OtherRaster
Array2D<float> tmp = OtherRaster.get_RasterData();
min_max_val = Get_Maximum(tmp, NoDataValue);
}
// for each cell, if there is no paramter data but there is topo, fill in the data with the minimum/maximum value
// otherwise, just keep the minimum value.
for (int i = 0; i < NRows; ++i){
for (int j = 0; j < NCols; ++j){
if (DEM.get_data_element(i, j) != NoDataValue && OtherRaster.get_data_element(i,j) == NoDataValue){
data[i][j] = min_max_val;
}
else if (DEM.get_data_element(i, j) != NoDataValue && OtherRaster.get_data_element(i, j) != NoDataValue){
data[i][j] = OtherRaster.get_data_element(i,j);
}
}
}
RasterData = data.copy();
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
// This function calculates a snow thickenss (effective, in g cm^-2 for cosmogenic
// applications) based on a bilinear model such as that of P Kirchner: http://escholarship.org/uc/item/9zn1c1mk#page-8
// The paper is here: http://www.hydrol-earth-syst-sci.net/18/4261/2014/hess-18-4261-2014.html
// This paper also agrees withy this general trend:
// http://www.the-cryosphere.net/8/2381/2014/tc-8-2381-2014.pdf
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void LSDSoilHydroRaster::SetSnowEffDepthBilinear(float SlopeAscend, float SlopeDescend,
float PeakElevation, float PeakSnowpack, LSDRaster& Elevation)
{
float LocalElevation;
float ascendEffDepth;
float descendEffDepth;
float thisEffDepth = 0;
for (int row = 0; row <NRows; row++)
{
for (int col = 0; col<NCols; col++)
{
if (RasterData[row][col] != NoDataValue)
{
LocalElevation = Elevation.get_data_element(row,col);
if (LocalElevation != NoDataValue)
{
// get the effective depth on both the ascending and descending limb
ascendEffDepth = SlopeAscend*(LocalElevation-PeakElevation)+PeakSnowpack;
descendEffDepth = SlopeDescend*(LocalElevation-PeakElevation)+PeakSnowpack;
// the correct depth is the lesser of the two
if (ascendEffDepth < descendEffDepth)
{
thisEffDepth = ascendEffDepth;
}
else
{
thisEffDepth = descendEffDepth;
}
// if the depth is less than zero, then set to zero
if(thisEffDepth <0)
{
thisEffDepth = 0;
}
RasterData[row][col] = thisEffDepth;
}
else // if there ins't any elevation data, set the snow data to NoData
{
RasterData[row][col] = NoDataValue;
}
}
}
}
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
// This function calculates a snow thickenss (effective, in g cm^-2 for cosmogenic
// applications) based on a richard's equsion sigmoidal growth model
// It was propoesd to represent peak SWE so we cruedly apply it to average annual SWE
// see
// http://onlinelibrary.wiley.com/doi/10.1002/2015GL063413/epdf
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void LSDSoilHydroRaster::SetSnowEffDepthRichards(float MaximumEffDepth, float MaximumSlope, float v,
float lambda, LSDRaster& Elevation)
{
// Don't let V be less than or equal to zero
if (v <= 0)
{
v = 0.001;
}
// some variables to speed up compuation
float exp_term;
float thisEffDepth = 0;
float elev_mulitplier = (MaximumSlope/MaximumEffDepth)*pow((1+v),1+(1/v));
float LocalElevation;
for (int row = 0; row <NRows; row++)
{
for (int col = 0; col<NCols; col++)
{
if (RasterData[row][col] != NoDataValue)
{
LocalElevation = Elevation.get_data_element(row,col);
if (LocalElevation != NoDataValue)
{
// get the effective depth using the richards sigmoidal gorth function
exp_term = 1+v*exp(elev_mulitplier*(lambda-LocalElevation));
thisEffDepth = MaximumEffDepth*pow(exp_term,-(1/v));
// if the depth is less than zero, then set to zero
if(thisEffDepth <0)
{
thisEffDepth = 0;
}
// update the data
RasterData[row][col] = thisEffDepth;
}
else // if there ins't any elevation data, set the snow data to NoData
{
RasterData[row][col] = NoDataValue;
}
}
}
}
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// Calculate the factor of safety using the sinmap definition.
// Call with the dimensionless cohesion (C) raster.
// SWDG 13/6/16
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
LSDSoilHydroRaster LSDSoilHydroRaster::Calculate_sinmap_Fs(LSDRaster& Slope, LSDSoilHydroRaster& w, LSDSoilHydroRaster& r, LSDSoilHydroRaster& phi){
Array2D<float> Fs(NRows, NCols, NoDataValue);
for (int i = 1; i < NRows - 1; ++i){
for (int j = 1; j < NCols - 1; ++j){
if (RasterData[i][j] != NoDataValue){
Fs[i][j] = ( RasterData[i][j] + cos(Slope.get_data_element(i,j)) * (1.0-w.get_data_element(i,j)*r.get_data_element(i,j)) * tan(phi.get_data_element(i,j)) ) / sin(Slope.get_data_element(i,j));
}
}
}
LSDSoilHydroRaster output(NRows,NCols,XMinimum,YMinimum,DataResolution,NoDataValue,Fs,GeoReferencingStrings);
return output;
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// Calculate h, the soil depth normal to the slope, used in the factor of safety equation.
// Call with the soil thickness raster.
// SWDG 13/6/16
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
LSDSoilHydroRaster LSDSoilHydroRaster::Calculate_h(LSDRaster& Slope){
Array2D<float> h(NRows, NCols, NoDataValue);
for (int i = 1; i < NRows - 1; ++i){
for (int j = 1; j < NCols - 1; ++j){
if (RasterData[i][j] != NoDataValue){
h[i][j] = RasterData[i][j] * cos(Slope.get_data_element(i,j));
}
}
}
LSDSoilHydroRaster output(NRows,NCols,XMinimum,YMinimum,DataResolution,NoDataValue,h,GeoReferencingStrings);
return output;
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// this function prints chi values. It is used on the channel tree when channels are organized by links
// (that is organization switch == 0
//
// SMM 01/09/2012
//
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
void LSDIndexChannelTree::print_chi_vs_elevation_from_channel_tree(LSDRaster& Elevation, LSDFlowInfo& FlowInfo, LSDJunctionNetwork& ChannelNetwork,
float m_over_n, float A_0, string chi_vs_elev_fname)
{
if(organization_switch != 0)
{
cout << "LSDIndexChannelTree you can't run LSDIndexChannelTree::print_chi_vs_elevation_from_channel_tree with this channel organization" << endl;
exit(EXIT_FAILURE);
}
int n_channels = IndexChannelVector.size();
int n_nodes_in_link,current_node_index;
vector< vector<float> > chi_vectors = calculate_chi_from_channel_tree(FlowInfo, ChannelNetwork,
m_over_n, A_0);
// the chi iterator
vector< vector<float> >::iterator chi_iter;
chi_iter = chi_vectors.begin();
float current_chi;
float current_elev;
int curr_row,curr_col;
ofstream chi_elev_out;
chi_elev_out.open(chi_vs_elev_fname.c_str());
for (int i = 0; i<n_channels; i++)
{
n_nodes_in_link = IndexChannelVector[i].get_n_nodes_in_channel();
for (int this_node = 0; this_node<n_nodes_in_link; this_node++)
{
current_node_index = IndexChannelVector[i].get_node_in_channel(this_node);
current_chi = (*chi_iter)[this_node];
FlowInfo.retrieve_current_row_and_col(current_node_index,curr_row,curr_col);
current_elev = Elevation.get_data_element(curr_row,curr_col);
//cout << "current_node: " << current_node_index << " and chi: " << current_chi << endl;
//chi_elev_out << current_chi << " " << current_elev << endl;
}
chi_iter++;
}
chi_elev_out.close();
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=---=-=-=-=-=-=-=-=-=-=-=-=-
// this function prints chi and elevation, along with flow distance and the
// number of the tributary it all goes to one file
//
// the file format is
// channel_number node_index row column flow_dist chi elevation drainage_area
//
// SMM 01/09/2012
//
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void LSDIndexChannelTree::print_LSDChannels_from_tree(float m_over_n, float A_0, LSDFlowInfo& FlowInfo,
LSDRaster& Elevation_Raster, LSDRaster& FlowDistance, string fname)
{
if (organization_switch != 1)
{
cout << "LSDIndexChannelTree you can't run LSDIndexChannelTree::retrieve_LSDChannels_from_tree" << endl;
cout << "with this channel organization, organization switch: " << organization_switch << endl;
exit(EXIT_FAILURE);
}
// open the outfile
ofstream channelfile_out;
channelfile_out.open(fname.c_str());
// get the vector of channels
vector<LSDChannel> vector_of_channels = retrieve_LSDChannels_from_tree(m_over_n, A_0, FlowInfo,Elevation_Raster);
int n_channels = vector_of_channels.size();
int n_nodes_in_channel;
int node,row,col;
float elev,chi,drain_area,flow_dist;
//loop through the channels
for (int i = 0; i< n_channels; i++)
{
// get the number of nodes in the channel
n_nodes_in_channel =IndexChannelVector[i].get_n_nodes_in_channel();
// now loop through the channel, printing out the data.
for(int ch_node= 0; ch_node<n_nodes_in_channel; ch_node++)
{
IndexChannelVector[i].get_node_row_col_in_channel(ch_node, node, row, col);
vector_of_channels[i].retrieve_node_information(ch_node, elev, chi, drain_area);
flow_dist = FlowDistance.get_data_element(row,col);
// print data to file
channelfile_out << i << " " << node << " " << row << " " << col << " " << flow_dist << " "
<< chi << " " << elev << " " << drain_area << endl;
}
}
channelfile_out.close();
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
// This prints a chi map to csv with an area threshold in m^2. You feed it the chi map
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void LSDChiTools::chi_map_to_csv(LSDFlowInfo& FlowInfo, string chi_map_fname,
LSDRaster& chi_coord)
{
ofstream chi_map_csv_out;
chi_map_csv_out.open(chi_map_fname.c_str());
float this_chi_coord;
double latitude,longitude;
LSDCoordinateConverterLLandUTM Converter;
chi_map_csv_out << "latitude,longitude,chi" << endl;
float NDV = chi_coord.get_NoDataValue();
for(int row = 0; row<NRows; row++)
{
for(int col = 0; col<NCols; col++)
{
this_chi_coord = chi_coord.get_data_element(row,col);
if (this_chi_coord != NDV)
{
get_lat_and_long_locations(row, col, latitude, longitude, Converter);
chi_map_csv_out.precision(9);
chi_map_csv_out << latitude << "," << longitude << ",";
chi_map_csv_out.precision(5);
chi_map_csv_out << this_chi_coord << endl;
}
}
}
chi_map_csv_out.close();
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
// This function is for calculating segments from all sources in a DEM
// The sources and their outlets are supplied by the source and outlet nodes
// vectors. These are generated from the LSDJunctionNetwork function
// get_overlapping_channels
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void LSDChiTools::chi_map_automator(LSDFlowInfo& FlowInfo,
vector<int> source_nodes,
vector<int> outlet_nodes,
LSDRaster& Elevation, LSDRaster& FlowDistance,
LSDRaster& DrainageArea, LSDRaster& chi_coordinate,
int target_nodes,
int n_iterations, int skip,
int minimum_segment_length, float sigma)
{
// IMPORTANT THESE PARAMETERS ARE NOT USED BECAUSE CHI IS CALUCALTED SEPARATELY
// However we need to give something to pass to the Monte carlo functions
// even through they are not used (they are inherited)
float A_0 = 1;
float m_over_n = 0.5;
// These elements access the chi data
vector< vector<float> > chi_m_means;
vector< vector<float> > chi_b_means;
vector< vector<float> > chi_coordinates;
vector< vector<int> > chi_node_indices;
// these are for the individual channels
vector<float> these_chi_m_means;
vector<float> these_chi_b_means;
vector<float> these_chi_coordinates;
vector<int> these_chi_node_indices;
// these are maps that will store the data
map<int,float> m_means_map;
map<int,float> b_means_map;
map<int,float> chi_coord_map;
map<int,float> elev_map;
map<int,float> area_map;
map<int,float> flow_distance_map;
vector<int> node_sequence_vec;
// these are for working with the FlowInfo object
int this_node,row,col;
// get the number of channels
int n_channels = int(source_nodes.size());
for(int chan = 0; chan<n_channels; chan++)
{
cout << "Sampling channel " << chan+1 << " of " << n_channels << endl;
// get this particualr channel (it is a chi network with only one channel)
LSDChiNetwork ThisChiChannel(FlowInfo, source_nodes[chan], outlet_nodes[chan],
Elevation, FlowDistance, DrainageArea,chi_coordinate);
// split the channel
//cout << "Splitting channels" << endl;
ThisChiChannel.split_all_channels(A_0, m_over_n, n_iterations, skip, target_nodes, minimum_segment_length, sigma);
// monte carlo sample all channels
//cout << "Entering the monte carlo sampling" << endl;
ThisChiChannel.monte_carlo_sample_river_network_for_best_fit_after_breaks(A_0, m_over_n, n_iterations, skip, minimum_segment_length, sigma);
// okay the ChiNetwork has all the data about the m vales at this stage.
// Get these vales and print them to a raster
chi_m_means = ThisChiChannel.get_m_means();
chi_b_means = ThisChiChannel.get_b_means();
chi_coordinates = ThisChiChannel.get_chis();
chi_node_indices = ThisChiChannel.get_node_indices();
// now get the number of channels. This should be 1!
int n_channels = int(chi_m_means.size());
if (n_channels != 1)
{
cout << "Whoa there, I am trying to make a chi map but something seems to have gone wrong with the channel extraction." << endl;
cout << "I should only have one channel per look but I have " << n_channels << " channels." << endl;
}
// now get the m_means out
these_chi_m_means = chi_m_means[0];
these_chi_b_means = chi_b_means[0];
these_chi_coordinates = chi_coordinates[0];
these_chi_node_indices = chi_node_indices[0];
//cout << "I have " << these_chi_m_means.size() << " nodes." << endl;
int n_nodes_in_channel = int(these_chi_m_means.size());
for (int node = 0; node< n_nodes_in_channel; node++)
{
this_node = these_chi_node_indices[node];
//cout << "This node is " << this_node << endl;
// only take the nodes that have not been found
if (m_means_map.find(this_node) == m_means_map.end() )
{
FlowInfo.retrieve_current_row_and_col(this_node,row,col);
//cout << "This is a new node; " << this_node << endl;
m_means_map[this_node] = these_chi_m_means[node];
b_means_map[this_node] = these_chi_b_means[node];
chi_coord_map[this_node] = these_chi_coordinates[node];
elev_map[this_node] = Elevation.get_data_element(row,col);
area_map[this_node] = DrainageArea.get_data_element(row,col);
flow_distance_map[this_node] = FlowDistance.get_data_element(row,col);
node_sequence_vec.push_back(this_node);
}
else
{
//cout << "I already have node: " << this_node << endl;
}
}
}
// set the opject data members
M_chi_data_map =m_means_map;
b_chi_data_map = b_means_map;
elev_data_map = elev_map;
chi_data_map = chi_coord_map;
flow_distance_data_map = flow_distance_map;
drainage_area_data_map = area_map;
node_sequence = node_sequence_vec;
}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
// This function is a much more rudimentary version that mimics the
// channel steepness caluclations.
// chi needs tobe calculated outside of the function
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void LSDChiTools::chi_map_automator_rudimentary(LSDFlowInfo& FlowInfo,
vector<int> source_nodes,
vector<int> outlet_nodes,
LSDRaster& Elevation, LSDRaster& FlowDistance,
LSDRaster& DrainageArea, LSDRaster& chi_coordinate,
int regression_nodes)
{
// the data is stored in maps, for easier testing if a node has been
// visited.
// You might consider having these as data elements in the object so you don't
// have to pass them
map<int,float> gradient_data_map;
map<int,float> intercept_data_map;
map<int,float> R2_data_map;
map<int,float> chi_coordinate_data_map;
map<int,float> elevation_data_map;
map<int,float> flow_distance_map;
map<int,float> area_map;
vector<int> node_order;
// check if the number of nodes are odd .If not add 1
if (regression_nodes % 2 == 0)
{
cout << "Hello user. You need an odd number of regression nodes." << endl;
regression_nodes = regression_nodes+1;
cout << " Changing your regression nodes to " << regression_nodes << endl;
}
// now get the midpoint
int mp_nodes = (regression_nodes-1)/2;
//cout << "The number of mp nodes is: " << mp_nodes << endl;
// these keep track of the beginning and ending nodes of a given channel
int channel_start_node;
int channel_end_node;
float channel_end_elevation;
// vectors for holding the chi elevation data
vector<float> chi_vec;
vector<float> elev_vec;
vector<float> empty_vec;
// these are extracted from the channel segments using linear regression
float intercept,gradient,R_squared;
//float this_chi;
//float this_elev;
int this_mp_node;
int this_end_node;
int this_start_node;
// these are for getting information out of the FlowInfo object
int row,col, this_node;
int r_node, r_row,r_col; // reciever row and column.
// The way this works is that it starts at the top of a channel. It then works
// its way down and find the node that is the midpoint and the node that is the
// end point. The midpoint node is where the data will be recorded.
// It then puts the data from the start node to the end node into a vector
// and performs a linear regression of this vector. The regression data from these
// vectors are recorded at the nodes.
// We then want to cover all the nodes with data so what happens if some nodes
// do not become midpoints?
// We could start at the top and get the first midpoint.
// From there we can work our way down checking if the top of the regression segment
// is more than one node down from the end point...
// get the number of channels
int n_channels = int(source_nodes.size());
// now loop through the channels
for(int chan = 0; chan<n_channels; chan++)
{
channel_start_node = source_nodes[chan];
channel_end_node = outlet_nodes[chan];
// Get the elevation of the end node as a secondary check of the ending of the channel
// segment
FlowInfo.retrieve_current_row_and_col(channel_end_node,row,col);
channel_end_elevation = Elevation.get_data_element(row,col);
// reset the flag for ending the channel
bool is_end_of_channel = false;
// set the segment start node to the channel start node
this_start_node = channel_start_node;
// now retrieve the midpoint node
this_node = channel_start_node;
for(int n = 0; n<mp_nodes; n++)
{
FlowInfo.retrieve_receiver_information(this_node,r_node,r_row,r_col);
this_node = r_node;
}
this_mp_node = this_node;
this_node = r_node;
// now go down one step
FlowInfo.retrieve_receiver_information(this_node,r_node,r_row,r_col);
this_node = r_node;
// now get the end node
for(int n = 0; n<mp_nodes; n++)
{
FlowInfo.retrieve_receiver_information(this_node,r_node,r_row,r_col);
this_node = r_node;
}
this_end_node = this_node;
//================================================
// This loop is for bug checking
//this_node = this_start_node;
//do
//{
// // get the elevation and chi vectors by following the flow
// cout << "This node is: " << this_node << endl;
// FlowInfo.retrieve_current_row_and_col(this_node,row,col);
// FlowInfo.retrieve_receiver_information(this_node,r_node,r_row,r_col);
// this_node = r_node;
//}
//while(this_node != this_end_node);
//
//cout << "And the midpoint node was: " << this_mp_node << endl;
//================================================
// we search down the channel, collecting linear regressions at the
// midpoint of the intervals
while (not is_end_of_channel)
{
// get a vector of chi and elevation from the start node to the end node
chi_vec = empty_vec;
elev_vec = empty_vec;
// copy the data elements into the vecotrs. This is a little stupid
// because one might just use a deque to pop the first element
// and push the last, but the linear regression takes vectors,
// not deques so you would have to copy the deque element-wise anyway
// If you wanted, you could speed this up by implementing a linear regression
// of deques, but that will need to wait for another day.
this_node = this_start_node;
do
{
// get the elevation and chi vectors by following the flow
FlowInfo.retrieve_current_row_and_col(this_node,row,col);
chi_vec.push_back(chi_coordinate.get_data_element(row,col));
elev_vec.push_back(Elevation.get_data_element(row,col));
FlowInfo.retrieve_receiver_information(this_node,r_node,r_row,r_col);
this_node = r_node;
} while(this_node != this_end_node);
// do a linear regression on the segment
least_squares_linear_regression(chi_vec,elev_vec, intercept, gradient, R_squared);
// now add the intercept and gradient data to the correct node
// only take data that has not been calculated before
// The channels are in order of descending length so data from
// longer channels take precidence.
if (gradient_data_map.find(this_mp_node) == gradient_data_map.end() )
{
FlowInfo.retrieve_current_row_and_col(this_mp_node,row,col);
gradient_data_map[this_mp_node] = gradient;
intercept_data_map[this_mp_node] = intercept;
R2_data_map[this_mp_node] = R_squared;
chi_coordinate_data_map[this_mp_node] = chi_coordinate.get_data_element(row,col);
elevation_data_map[this_mp_node] = Elevation.get_data_element(row,col);
flow_distance_map[this_mp_node] = FlowDistance.get_data_element(row,col);
area_map[this_mp_node] = DrainageArea.get_data_element(row,col);
node_order.push_back(this_mp_node);
}
else
{
is_end_of_channel = true;
}
// now move all the nodes down one
FlowInfo.retrieve_receiver_information(this_start_node,r_node,r_row,r_col);
this_start_node = r_node;
FlowInfo.retrieve_receiver_information(this_mp_node,r_node,r_row,r_col);
this_mp_node = r_node;
FlowInfo.retrieve_receiver_information(this_end_node,r_node,r_row,r_col);
this_end_node = r_node;
// check if we are at the end of the channel
if (this_end_node == channel_end_node)
{
is_end_of_channel = true;
}
// also check if the end node is lower elevation than the end node,
// just to try and stop the channel passing the end node
FlowInfo.retrieve_current_row_and_col(this_end_node,row,col);
if (channel_end_elevation > Elevation.get_data_element(row,col))
{
is_end_of_channel = true;
}
} // This finishes the regression segment loop
} // This finishes the channel and resets channel start and end nodes
// set the data objects
M_chi_data_map = gradient_data_map;
b_chi_data_map = intercept_data_map;
elev_data_map = elevation_data_map;
chi_data_map = chi_coordinate_data_map;
flow_distance_data_map = flow_distance_map;
drainage_area_data_map = area_map;
node_sequence = node_order;
}