int main(int argc , char ** argv) { int i = 10; int j = 5; int k = 16; double CF = 0; bool open = true; test_install_SIGNALS(); { well_conn_dir_enum dir = well_conn_dirX; well_conn_type * conn = well_conn_alloc(i,j,k,CF,dir,open); well_conn_type * conn2 = well_conn_alloc(i,j,k,CF,dir,open); well_conn_type * conn3 = well_conn_alloc(i,j,k+1,CF,dir,open); test_assert_not_NULL( conn ); test_assert_true( well_conn_is_instance( conn )); test_assert_int_equal( i , well_conn_get_i( conn )); test_assert_int_equal( j , well_conn_get_j( conn )); test_assert_int_equal( k , well_conn_get_k( conn )); test_assert_int_equal( dir , well_conn_get_dir( conn )); test_assert_bool_equal( open , well_conn_open( conn )); test_assert_false( well_conn_MSW( conn )); test_assert_true( well_conn_matrix_connection( conn )); test_assert_true( well_conn_equal( conn , conn2 )); test_assert_false( well_conn_equal( conn , conn3 )); test_assert_double_equal( CF , well_conn_get_connection_factor( conn )); well_conn_free( conn3 ); well_conn_free( conn2 ); well_conn_free( conn ); } { well_conn_dir_enum dir = well_conn_fracX; well_conn_type * conn = well_conn_alloc(i,j,k,CF,dir,open); test_assert_NULL( conn ); } { well_conn_dir_enum dir = well_conn_fracX; well_conn_type * conn = well_conn_alloc_fracture(i,j,k,CF,dir,open); test_assert_not_NULL( conn ); test_assert_int_equal( i , well_conn_get_i( conn )); test_assert_int_equal( j , well_conn_get_j( conn )); test_assert_int_equal( k , well_conn_get_k( conn )); test_assert_bool_equal( open , well_conn_open( conn )); test_assert_int_equal( dir , well_conn_get_dir( conn )); test_assert_false( well_conn_MSW( conn )); test_assert_false( well_conn_matrix_connection( conn )); test_assert_true( well_conn_fracture_connection( conn )); well_conn_free( conn ); } { well_conn_dir_enum dir = well_conn_dirX; well_conn_type * conn = well_conn_alloc_fracture(i,j,k,CF,dir,open); test_assert_not_NULL( conn ); well_conn_free( conn ); } { int segment = 16; well_conn_dir_enum dir = well_conn_dirX; well_conn_type * conn = well_conn_alloc_MSW(i,j,k,CF,dir,open,segment); test_assert_not_NULL( conn ); test_assert_int_equal( i , well_conn_get_i( conn )); test_assert_int_equal( j , well_conn_get_j( conn )); test_assert_int_equal( k , well_conn_get_k( conn )); test_assert_int_equal( segment , well_conn_get_segment_id( conn )); test_assert_bool_equal( open , well_conn_open( conn )); test_assert_int_equal( dir , well_conn_get_dir( conn )); test_assert_true( well_conn_MSW( conn )); test_assert_true( well_conn_matrix_connection( conn )); well_conn_free( conn ); } { int segment = 16; well_conn_dir_enum dir = well_conn_fracX; well_conn_type * conn = well_conn_alloc_fracture_MSW(i,j,k,CF,dir,open,segment); test_assert_not_NULL( conn ); test_assert_int_equal( i , well_conn_get_i( conn )); test_assert_int_equal( j , well_conn_get_j( conn )); test_assert_int_equal( k , well_conn_get_k( conn )); test_assert_int_equal( segment , well_conn_get_segment_id( conn )); test_assert_bool_equal( open , well_conn_open( conn )); test_assert_int_equal( dir , well_conn_get_dir( conn )); test_assert_true( well_conn_MSW( conn )); test_assert_false( well_conn_matrix_connection( conn )); well_conn_free( conn ); } test_conn_rate(); }
int main( int argc , char ** argv) { signal(SIGSEGV , util_abort_signal); /* Segmentation violation, i.e. overwriting memory ... */ signal(SIGTERM , util_abort_signal); /* If killing the enkf program with SIGTERM (the default kill signal) you will get a backtrace. Killing with SIGKILL (-9) will not give a backtrace.*/ signal(SIGABRT , util_abort_signal); /* Signal abort. */ { well_info_type * well_info = well_info_alloc( NULL ); int i; for (i=1; i < argc; i++) { printf("Loading file: %s \n",argv[i]); well_info_load_rstfile( well_info , argv[i]); } // List all wells: { int iwell; for (iwell = 0; iwell < well_info_get_num_wells( well_info ); iwell++) { well_ts_type * well_ts = well_info_get_ts( well_info , well_info_iget_well_name( well_info , iwell)); well_state_type * well_state = well_ts_get_last_state( well_ts ); well_state_summarize( well_state , stdout ); printf("\n"); } } well_info_free( well_info ); exit(1); // Look at the timeseries for one well: { well_ts_type * well_ts = well_info_get_ts( well_info , well_info_iget_well_name( well_info , 0)); int i; for (i =0; i < well_ts_get_size( well_ts ); i++) { well_state_type * well_state = well_ts_iget_state( well_ts , i ); printf("Well:%s report:%04d state:",well_state_get_name( well_state ), well_state_get_report_nr( well_state )); if (well_state_is_open( well_state )) printf("OPEN\n"); else printf("CLOSED\n"); } } // Look at one well_state: { well_state_type * well_state = well_info_iiget_state( well_info , 0 , 0 ); printf("Well:%s report:%04d \n",well_state_get_name( well_state ), well_state_get_report_nr( well_state )); { const well_conn_type ** connections = well_state_get_connections( well_state , 0 ); printf("Branches: %d \n",well_state_get_num_branches( well_state )); printf("num_connections: %d \n",well_state_get_num_connections( well_state , 0 )); { int iconn; for (iconn = 0; iconn < well_state_get_num_connections( well_state , 0 ); iconn++) { well_conn_type * conn = connections[ iconn ]; printf("Connection:%02d i=%3d j=%3d k=%3d State:",iconn , well_conn_get_i( conn ) , well_conn_get_j( conn ) , well_conn_get_k( conn )); if (well_conn_open( conn ) ) printf("Open\n"); else printf("Closed\n"); } } } } well_info_free( well_info ); } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RifReaderEclipseOutput::readWellCells(RigReservoir* reservoir) { CVF_ASSERT(reservoir); if (m_dynamicResultsAccess.isNull()) return; well_info_type* ert_well_info = well_info_alloc(NULL); if (!ert_well_info) return; m_dynamicResultsAccess->readWellData(ert_well_info); RigMainGrid* mainGrid = reservoir->mainGrid(); std::vector<RigGridBase*> grids; reservoir->allGrids(&grids); cvf::Collection<RigWellResults> wells; caf::ProgressInfo progress(well_info_get_num_wells(ert_well_info), ""); int wellIdx; for (wellIdx = 0; wellIdx < well_info_get_num_wells(ert_well_info); wellIdx++) { const char* wellName = well_info_iget_well_name(ert_well_info, wellIdx); CVF_ASSERT(wellName); cvf::ref<RigWellResults> wellResults = new RigWellResults; wellResults->m_wellName = wellName; well_ts_type* ert_well_time_series = well_info_get_ts(ert_well_info , wellName); int timeStepCount = well_ts_get_size(ert_well_time_series); wellResults->m_wellCellsTimeSteps.resize(timeStepCount); int timeIdx; for (timeIdx = 0; timeIdx < timeStepCount; timeIdx++) { well_state_type* ert_well_state = well_ts_iget_state(ert_well_time_series, timeIdx); RigWellResultFrame& wellResFrame = wellResults->m_wellCellsTimeSteps[timeIdx]; // Build timestamp for well // Also see RifEclipseOutputFileAccess::timeStepsText for accessing time_t structures { time_t stepTime = well_state_get_sim_time(ert_well_state); wellResFrame.m_timestamp = QDateTime::fromTime_t(stepTime); } // Production type well_type_enum ert_well_type = well_state_get_type(ert_well_state); if (ert_well_type == PRODUCER) { wellResFrame.m_productionType = RigWellResultFrame::PRODUCER; } else if (ert_well_type == WATER_INJECTOR) { wellResFrame.m_productionType = RigWellResultFrame::WATER_INJECTOR; } else if (ert_well_type == GAS_INJECTOR) { wellResFrame.m_productionType = RigWellResultFrame::GAS_INJECTOR; } else if (ert_well_type == OIL_INJECTOR) { wellResFrame.m_productionType = RigWellResultFrame::OIL_INJECTOR; } else { wellResFrame.m_productionType = RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE; } wellResFrame.m_isOpen = well_state_is_open( ert_well_state ); // Loop over all the grids in the model. If we have connections in one, we will discard // the maingrid connections as they are "duplicates" bool hasWellConnectionsInLGR = false; for (size_t gridNr = 1; gridNr < grids.size(); ++gridNr) { int branchCount = well_state_iget_lgr_num_branches(ert_well_state, static_cast<int>(gridNr)); if (branchCount > 0) { hasWellConnectionsInLGR = true; break; } } size_t gridNr = hasWellConnectionsInLGR ? 1 : 0; for (; gridNr < grids.size(); ++gridNr) { // Wellhead. If several grids have a wellhead definition for this well, we use tha last one. (Possibly the innermost LGR) const well_conn_type* ert_wellhead = well_state_iget_wellhead(ert_well_state, static_cast<int>(gridNr)); if (ert_wellhead) { int cellI = well_conn_get_i( ert_wellhead ); int cellJ = well_conn_get_j( ert_wellhead ); int cellK = CVF_MAX(0, well_conn_get_k(ert_wellhead)); // Why this ? // If a well is defined in fracture region, the K-value is from (cellCountK - 1) -> cellCountK*2 - 1 // Adjust K so index is always in valid grid region if (cellK >= grids[gridNr]->cellCountK()) { cellK -= static_cast<int>(grids[gridNr]->cellCountK()); } wellResFrame.m_wellHead.m_gridCellIndex = grids[gridNr]->cellIndexFromIJK(cellI, cellJ, cellK); wellResFrame.m_wellHead.m_gridIndex = gridNr; } int branchCount = well_state_iget_lgr_num_branches(ert_well_state, static_cast<int>(gridNr)); if (branchCount > 0) { if (static_cast<int>(wellResFrame.m_wellResultBranches.size()) < branchCount) wellResFrame.m_wellResultBranches.resize(branchCount); for (int branchIdx = 0; branchIdx < branchCount; ++branchIdx ) { // Connections int connectionCount = well_state_iget_num_lgr_connections(ert_well_state, static_cast<int>(gridNr), branchIdx); if (connectionCount > 0) { RigWellResultBranch& wellSegment = wellResFrame.m_wellResultBranches[branchIdx]; // Is this completely right? Is the branch index actually the same between lgrs ? wellSegment.m_branchNumber = branchIdx; size_t existingConnCount = wellSegment.m_wellCells.size(); wellSegment.m_wellCells.resize(existingConnCount + connectionCount); int connIdx; for (connIdx = 0; connIdx < connectionCount; connIdx++) { const well_conn_type* ert_connection = well_state_iget_lgr_connections( ert_well_state, static_cast<int>(gridNr), branchIdx)[connIdx]; CVF_ASSERT(ert_connection); RigWellResultCell& data = wellSegment.m_wellCells[existingConnCount + connIdx]; data.m_gridIndex = gridNr; { int cellI = well_conn_get_i( ert_connection ); int cellJ = well_conn_get_j( ert_connection ); int cellK = well_conn_get_k( ert_connection ); bool open = well_conn_open( ert_connection ); int branch = well_conn_get_branch( ert_connection ); int segment = well_conn_get_segment( ert_connection ); // If a well is defined in fracture region, the K-value is from (cellCountK - 1) -> cellCountK*2 - 1 // Adjust K so index is always in valid grid region if (cellK >= grids[gridNr]->cellCountK()) { cellK -= static_cast<int>(grids[gridNr]->cellCountK()); } data.m_gridCellIndex = grids[gridNr]->cellIndexFromIJK(cellI , cellJ , cellK); data.m_isOpen = open; data.m_branchId = branch; data.m_segmentId = segment; } } } } } } } wellResults->computeMappingFromResultTimeIndicesToWellTimeIndices(m_timeSteps); wells.push_back(wellResults.p()); progress.incrementProgress(); } well_info_free(ert_well_info); reservoir->setWellResults(wells); }