inline
std::vector<int>
buildAllCells(const int nc)
{
std::vector<int> all_cells(nc);
for (int c = 0; c < nc; ++c) { all_cells[c] = c; }
return all_cells;
}
void PCAFeature::train_pca()
{
// prepare the PCA.
// (1) collect training examples
cout << "PCAFeature: collecting" << endl;
vector<shared_ptr<MetaData> > all_data; // unsupervised so we can do this
auto load_insert_examples = [&all_data](string direct)
{
vector<shared_ptr<MetaData> > some_data = metadata_build_all(direct);
all_data.insert(all_data.end(),some_data.begin(),some_data.end());
};
for(string&test_dir : default_test_dirs())
load_insert_examples(test_dir);
//load_insert_examples(default_train_dir());
// (2) collect the cells for the PCA
shared_ptr<const ImRGBZ> im0 = cropToCells(*all_data[0]->load_im());
int winX = im0->cols();
int winY = im0->rows();
unique_ptr<SubComputer> hog_for_scale(
new SubComputer(Size(winX,winY),block_size,block_stride,cell_size));
int nbins = hog_for_scale->getNBins();
Mat all_cells(0,nbins,DataType<float>::type);
for(shared_ptr<MetaData> & metadata : all_data)
{
// compute all cells in the image
shared_ptr<const ImRGBZ> im = cropToCells(*metadata->load_im());
vector<float> feats; hog_for_scale->compute(*im,feats);
assert(feats.size()%nbins == 0);
for(int cell_iter = 0; cell_iter < feats.size()/nbins; cell_iter++)
{
// extract each cell in the image
auto begin = feats.begin() + nbins*cell_iter;
auto end = begin + nbins;
vector<float> cell(begin,end);
Mat cell_mat(cell); cell_mat = cell_mat.t();
assert(cell_mat.rows == 1 && cell_mat.cols == nbins);
all_cells.push_back<float>(cell_mat);
}
}
// (3) run the PCA
cout << "PCAFeature: computing" << endl;
g_pca_reducer.reset(new cv::PCA(all_cells,noArray(),CV_PCA_DATA_AS_ROW,FEAT_DIM));
cout << "PCAFeature: ready" << endl;
// (4) save the PCA?
FileStorage cache_storage("cache/PCA.yml",FileStorage::WRITE);
cache_storage << "pca_eig_values" << g_pca_reducer->eigenvalues;
cache_storage << "pca_eig_vectors" << g_pca_reducer->eigenvectors;
cache_storage << "pca_mean" << g_pca_reducer->mean;
cache_storage.release();
}
void initStateBasic(const UnstructuredGrid& grid,
const BlackoilPropertiesInterface& props,
const parameter::ParameterGroup& param,
const double gravity,
State& state)
{
// TODO: Refactor to exploit similarity with IncompProp* case.
const int num_phases = props.numPhases();
if (num_phases != 2) {
THROW("initStateTwophaseBasic(): currently handling only two-phase scenarios.");
}
state.init(grid, num_phases);
const int num_cells = props.numCells();
// By default: initialise water saturation to minimum everywhere.
std::vector<int> all_cells(num_cells);
for (int i = 0; i < num_cells; ++i) {
all_cells[i] = i;
}
state.setFirstSat(all_cells, props, State::MinSat);
const bool convection_testcase = param.getDefault("convection_testcase", false);
if (convection_testcase) {
// Initialise water saturation to max in the 'left' part.
std::vector<int> left_cells;
left_cells.reserve(num_cells/2);
const int *glob_cell = grid.global_cell;
const int* cd = grid.cartdims;
for (int cell = 0; cell < num_cells; ++cell) {
const int gc = glob_cell == 0 ? cell : glob_cell[cell];
bool left = (gc % cd[0]) < cd[0]/2;
if (left) {
left_cells.push_back(cell);
}
}
state.setFirstSat(left_cells, props, State::MaxSat);
const double init_p = param.getDefault("ref_pressure", 100.0)*unit::barsa;
std::fill(state.pressure().begin(), state.pressure().end(), init_p);
} else if (param.has("water_oil_contact")) {
// Warn against error-prone usage.
if (gravity == 0.0) {
std::cout << "**** Warning: running gravity convection scenario, but gravity is zero." << std::endl;
}
if (grid.cartdims[2] <= 1) {
std::cout << "**** Warning: running gravity convection scenario, which expects nz > 1." << std::endl;
}
// Initialise water saturation to max below water-oil contact.
const double woc = param.get<double>("water_oil_contact");
initWaterOilContact(grid, props, woc, WaterBelow, state);
// Initialise pressure to hydrostatic state.
const double ref_p = param.getDefault("ref_pressure", 100.0)*unit::barsa;
initHydrostaticPressure(grid, props, woc, gravity, woc, ref_p, state);
} else {
// Use default: water saturation is minimum everywhere.
// Initialise pressure to hydrostatic state.
const double ref_p = param.getDefault("ref_pressure", 100.0)*unit::barsa;
const double ref_z = grid.cell_centroids[0 + grid.dimensions - 1];
const double woc = -1e100;
initHydrostaticPressure(grid, props, woc, gravity, ref_z, ref_p, state);
}
// Finally, init face pressures.
initFacePressure(grid, state);
}
