static void parseVELFPVELOCFile(const QString&datFileName, Mesh* mesh) { // these files are optional, so if not present, reading is skipped int nnodes = mesh->nodes().size(); QFileInfo fi(datFileName); QVector<float> maxVel(nnodes); { QString nodesFileName(fi.dir().filePath("VELFP.OUT")); QFile nodesFile(nodesFileName); if (!nodesFile.open(QIODevice::ReadOnly | QIODevice::Text)) return; QTextStream nodesStream(&nodesFile); int node_inx = 0; // VELFP.OUT - COORDINATES (NODE NUM, X, Y, MAX VEL) - Maximum floodplain flow velocity; while (!nodesStream.atEnd()) { if (node_inx == nnodes) throw LoadStatus::Err_IncompatibleMesh; QString line = nodesStream.readLine(); QStringList lineParts = line.split(" ", QString::SkipEmptyParts); if (lineParts.size() != 4) { throw LoadStatus::Err_UnknownFormat; } float val = getFloat(lineParts[3]); maxVel[node_inx] = val; node_inx++; } } { QString nodesFileName(fi.dir().filePath("VELOC.OUT")); QFile nodesFile(nodesFileName); if (!nodesFile.open(QIODevice::ReadOnly | QIODevice::Text)) return; QTextStream nodesStream(&nodesFile); int node_inx = 0; // VELOC.OUT - COORDINATES (NODE NUM, X, Y, MAX VEL) - Maximum channel flow velocity while (!nodesStream.atEnd()) { if (node_inx == nnodes) throw LoadStatus::Err_IncompatibleMesh; QString line = nodesStream.readLine(); QStringList lineParts = line.split(" ", QString::SkipEmptyParts); if (lineParts.size() != 4) { throw LoadStatus::Err_UnknownFormat; } float val = getFloat(lineParts[3]); if (!is_nodata(val)) { // overwrite value from VELFP if it is not 0 maxVel[node_inx] = val; } node_inx++; } } addStaticDataset(maxVel, "Velocity/Maximums", DataSet::Scalar, datFileName, mesh); }
static float getFloat(const QString& val) { float valF = val.toFloat(); if (is_nodata(valF, 0.0f)) { return -9999.0; } else { return valF; } }
static void activateElements(NodeOutput* tos, const Mesh* mesh){ // Activate only elements that do all node's outputs with some data char* active = tos->active.data(); for (int idx=0; idx<mesh->elements().size(); ++idx) { Element elem = mesh->elements().at(idx); if (is_nodata(tos->values[elem.p(0)]) || is_nodata(tos->values[elem.p(1)]) || is_nodata(tos->values[elem.p(2)]) || is_nodata(tos->values[elem.p(3)])) { active[idx] = 0; //NOT ACTIVE } else { active[idx] = 1; //ACTIVE } } }
static double getDouble( double val ) { if ( is_nodata( val ) ) { return MDAL_NAN; } else { return val; } }
void weightWindow::compute(const dimension_type i, const dimension_type j, const genericWindow<elevation_type>& elevwin, const direction_type dir, const int trustdir) { elevation_type elev_crt, elev_neighb, e_diff; dimension_type i_neighb, j_neighb; /* initialize all weights to 0 */ init(); elev_crt = elevwin.get(); assert(!is_nodata(elev_crt)); /* map direction to neighbors */ directionWindow dirwin(dir); /* compute weights of the 8 neighbours */ int skipit = 0; for (short di = -1; di <= 1; di++) { for (short dj = -1; dj <= 1; dj++) { /* grid coordinates and elevation of neighbour */ i_neighb = i + di; j_neighb = j + dj; elev_neighb = elevwin.get(di, dj); e_diff = (elevation_type)(elev_crt - elev_neighb); skipit = ((di ==0) && (dj==0)); skipit |= (elev_crt < elev_neighb); /* skipit |= (elev_neighb == edge_nodata); ?? */ if (!trustdir) { dirwin.correctDirection(di,dj,skipit, i,j, elev_crt,dir,elev_neighb); } /* if direction points to it then compute its weight */ if (dirwin.get(di,dj) == true) { computeWeight(di,dj, elev_crt, elev_neighb); } } /* for dj */ } /* for di */ normalize(); /* normalize the weights */ #ifdef CHECK_WEIGHTS cout <<"weights: ["; for (int l=0;l<9;l++) cout << form("%3.2f ",weight.get(l)); cout <<"]\n"; #endif };
/* Find the dominant direction. Set corresponding weight to 1, and sets all other weights to 0. Set sumweight and sumcontour.*/ void weightWindow::makeD8(const dimension_type i, const dimension_type j, const genericWindow<elevation_type>& elevwin, const direction_type dir, const bool trustdir) { elevation_type elev_crt; short di,dj; elev_crt = elevwin.get(); assert(!is_nodata(elev_crt)); int maxi=0, maxj=0; double tanb, contour, maxtanb = -1, maxcontour = -1; /* map direction to neighbors */ directionWindow dirwin(dir); /* compute biggest angle to a neighbor */ for (di=-1; di <=1; di++) { for (dj = -1; dj <= 1; dj++) { if (dirwin.get(di,dj)) { tanb = computeTanB(di,dj, elevwin); contour = computeContour(di, dj); if (tanb > maxtanb) { maxtanb = tanb; maxi = di; maxj = dj; maxcontour = contour; } } } } /* at this point maxi and maxj must be set */ assert((maxi != 0 || maxj != 0) && maxtanb >= 0); /* set weights corresponding to this direction */ init(); /* initialize all weights to 0 */ int maxindex = 3* (maxi + 1) + maxj+1; weight.set(maxindex,1); /* set maxweight to 1 */ sumweight = 1; sumcontour = maxcontour; }
void MDAL::DriverFlo2D::parseDEPTHFile( const std::string &datFileName, const std::vector<double> &elevations ) { // this file is optional, so if not present, reading is skipped std::string depthFile( fileNameFromDir( datFileName, "DEPTH.OUT" ) ); if ( !MDAL::fileExists( depthFile ) ) { return; //optional file } std::ifstream depthStream( depthFile, std::ifstream::in ); std::string line; size_t nVertices = mMesh->verticesCount(); std::vector<double> maxDepth( nVertices ); std::vector<double> maxWaterLevel( nVertices ); size_t vertex_idx = 0; // DEPTH.OUT - COORDINATES (ELEM NUM, X, Y, MAX DEPTH) while ( std::getline( depthStream, line ) ) { line = MDAL::rtrim( line ); if ( vertex_idx == nVertices ) throw MDAL_Status::Err_IncompatibleMesh; std::vector<std::string> lineParts = MDAL::split( line, ' ' ); if ( lineParts.size() != 4 ) { throw MDAL_Status::Err_UnknownFormat; } double val = getDouble( lineParts[3] ); maxDepth[vertex_idx] = val; //water level if ( !is_nodata( val ) ) val += elevations[vertex_idx]; maxWaterLevel[vertex_idx] = val; vertex_idx++; } addStaticDataset( true, maxDepth, "Depth/Maximums", datFileName ); addStaticDataset( true, maxWaterLevel, "Water Level/Maximums", datFileName ); }
static void parseDEPTHFile(const QString&datFileName, Mesh* mesh, const QVector<float>& elevations) { // this file is optional, so if not present, reading is skipped QFileInfo fi(datFileName); QString nodesFileName(fi.dir().filePath("DEPTH.OUT")); QFile nodesFile(nodesFileName); if (!nodesFile.open(QIODevice::ReadOnly | QIODevice::Text)) return; QTextStream nodesStream(&nodesFile); int nnodes = mesh->nodes().size(); QVector<float> maxDepth(nnodes); QVector<float> maxWaterLevel(nnodes); int node_inx = 0; // DEPTH.OUT - COORDINATES (NODE NUM, X, Y, MAX DEPTH) while (!nodesStream.atEnd()) { if (node_inx == nnodes) throw LoadStatus::Err_IncompatibleMesh; QString line = nodesStream.readLine(); QStringList lineParts = line.split(" ", QString::SkipEmptyParts); if (lineParts.size() != 4) { throw LoadStatus::Err_UnknownFormat; } float val = getFloat(lineParts[3]); maxDepth[node_inx] = val; //water level if (!is_nodata(val)) val += elevations[node_inx]; maxWaterLevel[node_inx] = val; node_inx++; } addStaticDataset(maxDepth, "Depth/Maximums", DataSet::Scalar, datFileName, mesh); addStaticDataset(maxWaterLevel, "Water Level/Maximums", DataSet::Scalar, datFileName, mesh); }
void flow_waterWindower::processWindow(dimension_type i, dimension_type j, waterWindowBaseType *a, waterWindowBaseType *b, waterWindowBaseType *c) { elevation_type el1[3], el2[3], el3[3]; toporank_type ac1[3], ac2[3], ac3[3]; if (is_nodata(b[1].el)) { /*sweep_str does not include nodata */ return; } /*#ifdef COMPRESSED_WINDOWS sweepItem win = sweepItem(i, j, a, b, c); #else */ for (int k=0; k<3; k++) { el1[k] = a[k].el; ac1[k] = -a[k].depth; /*WEIRD */ el2[k] = b[k].el; ac2[k] = -b[k].depth; /*WEIRD*/ el3[k] = c[k].el; ac3[k] = -c[k].depth; /*WEIRD*/ } /* genericWindow<elevation_type> e_win(el); genericWindow<toporank_type> a_win(ac); sweepItem win = sweepItem(i, j, b[1].dir, e_win, a_win); */ sweepItem win = sweepItem(i, j, b[1].dir, el1, el2, el3, ac1, ac2, ac3); /* #endif */ AMI_err ae = sweep_str->write_item(win); assert(ae == AMI_ERROR_NO_ERROR); }
/*returns 1 if value is Nodata, 0 if it is not */ int is_nodata_grid(Grid * grid, float value) { assert(grid); return is_nodata(grid->hd, value); }
static void parseTIMDEPFile(const QString& datFileName, Mesh* mesh, const QVector<float>& elevations) {\ // TIMDEP.OUT // this file is optional, so if not present, reading is skipped // time (separate line) // For every node: // FLO2D: node number (indexed from 1), depth, velocity, velocity x, velocity y // FLO2DPro: node number (indexed from 1), depth, velocity, velocity x, velocity y, water surface elevation QFileInfo fi(datFileName); QFile inFile(fi.dir().filePath("TIMDEP.OUT")); if (!inFile.open(QIODevice::ReadOnly | QIODevice::Text)) return; QTextStream in(&inFile); int nnodes = mesh->nodes().size(); int nelems = mesh->elements().size(); int ntimes = 0; float time = 0.0; int node_inx = 0; DataSet* depthDs = new DataSet(datFileName); depthDs->setType(DataSet::Scalar); depthDs->setName("Depth"); DataSet* waterLevelDs = new DataSet(datFileName); waterLevelDs->setType(DataSet::Scalar); waterLevelDs->setName("Water Level"); DataSet* flowDs = new DataSet(datFileName); flowDs->setType(DataSet::Vector); flowDs->setName("Velocity"); NodeOutput* flowOutput = 0; NodeOutput* depthOutput = 0; NodeOutput* waterLevelOutput = 0; while (!in.atEnd()) { QString line = in.readLine(); QStringList lineParts = line.split(" ", QString::SkipEmptyParts); if (lineParts.size() == 1) { time = line.toFloat(); ntimes++; if (depthOutput) addOutput(depthDs, depthOutput, mesh); if (flowOutput) addOutput(flowDs, flowOutput, mesh); if (waterLevelOutput) addOutput(waterLevelDs, waterLevelOutput, mesh); depthOutput = new NodeOutput; flowOutput = new NodeOutput; waterLevelOutput = new NodeOutput; depthOutput->init(nnodes, nelems, false); //scalar flowOutput->init(nnodes, nelems, true); //vector waterLevelOutput->init(nnodes, nelems, false); //scalar depthOutput->time = time; flowOutput->time = time; waterLevelOutput->time = time; node_inx = 0; } else if ((lineParts.size() == 5) || (lineParts.size() == 6)) { // new node for time if (!depthOutput || !flowOutput || !waterLevelOutput) throw LoadStatus::Err_UnknownFormat; if (node_inx == nnodes) throw LoadStatus::Err_IncompatibleMesh; flowOutput->values[node_inx] = getFloat(lineParts[2]); flowOutput->valuesV[node_inx].x = getFloat(lineParts[3]); flowOutput->valuesV[node_inx].y = getFloat(lineParts[4]); float depth = getFloat(lineParts[1]); depthOutput->values[node_inx] = depth; if (!is_nodata(depth)) depth += elevations[node_inx]; waterLevelOutput->values[node_inx] = depth; node_inx ++; } else { throw LoadStatus::Err_UnknownFormat; } } if (depthOutput) addOutput(depthDs, depthOutput, mesh); if (flowOutput) addOutput(flowDs, flowOutput, mesh); if (waterLevelOutput) addOutput(waterLevelDs, waterLevelOutput, mesh); depthDs->setIsTimeVarying(ntimes>1); flowDs->setIsTimeVarying(ntimes>1); waterLevelDs->setIsTimeVarying(ntimes>1); depthDs->updateZRange(); flowDs->updateZRange(); waterLevelDs->updateZRange(); mesh->addDataSet(depthDs); mesh->addDataSet(flowDs); mesh->addDataSet(waterLevelDs); }
static double read_vgrid_value( PJ *defn, LP input, int *gridlist_count_p, PJ_GRIDINFO **tables, struct CTABLE *ct) { int itable = 0; double value = HUGE_VAL; double grid_x, grid_y; long grid_ix, grid_iy; long grid_ix2, grid_iy2; float *cvs; /* do not deal with NaN coordinates */ /* cppcheck-suppress duplicateExpression */ if( isnan(input.phi) || isnan(input.lam) ) itable = *gridlist_count_p; /* keep trying till we find a table that works */ for ( ; itable < *gridlist_count_p; itable++ ) { PJ_GRIDINFO *gi = tables[itable]; ct = gi->ct; /* skip tables that don't match our point at all. */ if( ct->ll.phi > input.phi || ct->ll.lam > input.lam || ct->ll.phi + (ct->lim.phi-1) * ct->del.phi < input.phi || ct->ll.lam + (ct->lim.lam-1) * ct->del.lam < input.lam ) continue; /* If we have child nodes, check to see if any of them apply. */ while( gi->child != NULL ) { PJ_GRIDINFO *child; for( child = gi->child; child != NULL; child = child->next ) { struct CTABLE *ct1 = child->ct; if( ct1->ll.phi > input.phi || ct1->ll.lam > input.lam || ct1->ll.phi+(ct1->lim.phi-1)*ct1->del.phi < input.phi || ct1->ll.lam+(ct1->lim.lam-1)*ct1->del.lam < input.lam) continue; break; } /* we didn't find a more refined child node to use, so go with current grid */ if( child == NULL ) { break; } /* Otherwise let's try for childrens children .. */ gi = child; ct = child->ct; } /* load the grid shift info if we don't have it. */ if( ct->cvs == NULL && !pj_gridinfo_load( pj_get_ctx(defn), gi ) ) { pj_ctx_set_errno( defn->ctx, PJD_ERR_FAILED_TO_LOAD_GRID ); return PJD_ERR_FAILED_TO_LOAD_GRID; } /* Interpolation a location within the grid */ grid_x = (input.lam - ct->ll.lam) / ct->del.lam; grid_y = (input.phi - ct->ll.phi) / ct->del.phi; grid_ix = lround(floor(grid_x)); grid_iy = lround(floor(grid_y)); grid_x -= grid_ix; grid_y -= grid_iy; grid_ix2 = grid_ix + 1; if( grid_ix2 >= ct->lim.lam ) grid_ix2 = ct->lim.lam - 1; grid_iy2 = grid_iy + 1; if( grid_iy2 >= ct->lim.phi ) grid_iy2 = ct->lim.phi - 1; cvs = (float *) ct->cvs; { float value_a = cvs[grid_ix + grid_iy * ct->lim.lam]; float value_b = cvs[grid_ix2 + grid_iy * ct->lim.lam]; float value_c = cvs[grid_ix + grid_iy2 * ct->lim.lam]; float value_d = cvs[grid_ix2 + grid_iy2 * ct->lim.lam]; double total_weight = 0.0; int n_weights = 0; value = 0.0f; if( !is_nodata(value_a) ) { double weight = (1.0-grid_x) * (1.0-grid_y); value += value_a * weight; total_weight += weight; n_weights ++; } if( !is_nodata(value_b) ) { double weight = (grid_x) * (1.0-grid_y); value += value_b * weight; total_weight += weight; n_weights ++; } if( !is_nodata(value_c) ) { double weight = (1.0-grid_x) * (grid_y); value += value_c * weight; total_weight += weight; n_weights ++; } if( !is_nodata(value_d) ) { double weight = (grid_x) * (grid_y); value += value_d * weight; total_weight += weight; n_weights ++; } if( n_weights == 0 ) value = HUGE_VAL; else if( n_weights != 4 ) value /= total_weight; } } return value; }
void MDAL::DriverFlo2D::parseVELFPVELOCFile( const std::string &datFileName ) { // these files are optional, so if not present, reading is skipped size_t nVertices = mMesh->verticesCount(); std::vector<double> maxVel( nVertices ); { std::string velocityFile( fileNameFromDir( datFileName, "VELFP.OUT" ) ); if ( !MDAL::fileExists( velocityFile ) ) { return; //optional file } std::ifstream velocityStream( velocityFile, std::ifstream::in ); std::string line; size_t vertex_idx = 0; // VELFP.OUT - COORDINATES (ELEM NUM, X, Y, MAX VEL) - Maximum floodplain flow velocity; while ( std::getline( velocityStream, line ) ) { if ( vertex_idx == nVertices ) throw MDAL_Status::Err_IncompatibleMesh; line = MDAL::rtrim( line ); std::vector<std::string> lineParts = MDAL::split( line, ' ' ); if ( lineParts.size() != 4 ) { throw MDAL_Status::Err_UnknownFormat; } double val = getDouble( lineParts[3] ); maxVel[vertex_idx] = val; vertex_idx++; } } { std::string velocityFile( fileNameFromDir( datFileName, "VELOC.OUT" ) ); if ( !MDAL::fileExists( velocityFile ) ) { return; //optional file } std::ifstream velocityStream( velocityFile, std::ifstream::in ); std::string line; size_t vertex_idx = 0; // VELOC.OUT - COORDINATES (ELEM NUM, X, Y, MAX VEL) - Maximum channel flow velocity while ( std::getline( velocityStream, line ) ) { if ( vertex_idx == nVertices ) throw MDAL_Status::Err_IncompatibleMesh; line = MDAL::rtrim( line ); std::vector<std::string> lineParts = MDAL::split( line, ' ' ); if ( lineParts.size() != 4 ) { throw MDAL_Status::Err_UnknownFormat; } double val = getDouble( lineParts[3] ); if ( !is_nodata( val ) ) // overwrite value from VELFP if it is not 0 { maxVel[vertex_idx] = val; } vertex_idx++; } } addStaticDataset( true, maxVel, "Velocity/Maximums", datFileName ); }
void MDAL::DriverFlo2D::parseTIMDEPFile( const std::string &datFileName, const std::vector<double> &elevations ) { // TIMDEP.OUT // this file is optional, so if not present, reading is skipped // time (separate line) // For every Vertex: // FLO2D: ELEM NUMber (indexed from 1), depth, velocity, velocity x, velocity y // FLO2DPro: ELEM NUMber (indexed from 1), depth, velocity, velocity x, velocity y, water surface elevation std::string inFile( fileNameFromDir( datFileName, "TIMDEP.OUT" ) ); if ( !MDAL::fileExists( inFile ) ) { return; } std::ifstream inStream( inFile, std::ifstream::in ); std::string line; size_t nVertexs = mMesh->verticesCount(); size_t ntimes = 0; double time = 0.0; size_t face_idx = 0; std::shared_ptr<DatasetGroup> depthDsGroup = std::make_shared< DatasetGroup >( name(), mMesh.get(), datFileName, "Depth" ); depthDsGroup->setIsOnVertices( false ); depthDsGroup->setIsScalar( true ); std::shared_ptr<DatasetGroup> waterLevelDsGroup = std::make_shared< DatasetGroup >( name(), mMesh.get(), datFileName, "Water Level" ); waterLevelDsGroup->setIsOnVertices( false ); waterLevelDsGroup->setIsScalar( true ); std::shared_ptr<DatasetGroup> flowDsGroup = std::make_shared< DatasetGroup >( name(), mMesh.get(), datFileName, "Velocity" ); flowDsGroup->setIsOnVertices( false ); flowDsGroup->setIsScalar( false ); std::shared_ptr<MDAL::MemoryDataset> flowDataset; std::shared_ptr<MDAL::MemoryDataset> depthDataset; std::shared_ptr<MDAL::MemoryDataset> waterLevelDataset; while ( std::getline( inStream, line ) ) { line = MDAL::rtrim( line ); std::vector<std::string> lineParts = MDAL::split( line, ' ' ); if ( lineParts.size() == 1 ) { time = MDAL::toDouble( line ); ntimes++; if ( depthDataset ) addDatasetToGroup( depthDsGroup, depthDataset ); if ( flowDataset ) addDatasetToGroup( flowDsGroup, flowDataset ); if ( waterLevelDataset ) addDatasetToGroup( waterLevelDsGroup, waterLevelDataset ); depthDataset = std::make_shared< MemoryDataset >( depthDsGroup.get() ); flowDataset = std::make_shared< MemoryDataset >( flowDsGroup.get() ); waterLevelDataset = std::make_shared< MemoryDataset >( waterLevelDsGroup.get() ); depthDataset->setTime( time ); flowDataset->setTime( time ); waterLevelDataset->setTime( time ); face_idx = 0; } else if ( ( lineParts.size() == 5 ) || ( lineParts.size() == 6 ) ) { // new Vertex for time if ( !depthDataset || !flowDataset || !waterLevelDataset ) throw MDAL_Status::Err_UnknownFormat; if ( face_idx == nVertexs ) throw MDAL_Status::Err_IncompatibleMesh; // this is magnitude: getDouble(lineParts[2]); flowDataset->values()[2 * face_idx] = getDouble( lineParts[3] ); flowDataset->values()[2 * face_idx + 1] = getDouble( lineParts[4] ); double depth = getDouble( lineParts[1] ); depthDataset->values()[face_idx] = depth; if ( !is_nodata( depth ) ) depth += elevations[face_idx]; waterLevelDataset->values()[face_idx] = depth; face_idx ++; } else { throw MDAL_Status::Err_UnknownFormat; } } if ( depthDataset ) addDatasetToGroup( depthDsGroup, depthDataset ); if ( flowDataset ) addDatasetToGroup( flowDsGroup, flowDataset ); if ( waterLevelDataset ) addDatasetToGroup( waterLevelDsGroup, waterLevelDataset ); depthDsGroup->setStatistics( MDAL::calculateStatistics( depthDsGroup ) ); flowDsGroup->setStatistics( MDAL::calculateStatistics( flowDsGroup ) ); waterLevelDsGroup->setStatistics( MDAL::calculateStatistics( waterLevelDsGroup ) ); mMesh->datasetGroups.push_back( depthDsGroup ); mMesh->datasetGroups.push_back( flowDsGroup ); mMesh->datasetGroups.push_back( waterLevelDsGroup ); }