CollOfScalar EquelleRuntimeCPU::solveForUpdate(const CollOfScalar& residual) const
{
Eigen::SparseMatrix<double, Eigen::RowMajor> matr = residual.derivative()[0];
CollOfScalar::V du = CollOfScalar::V::Zero(residual.size());
Opm::time::StopWatch clock;
clock.start();
// solve(n, # nonzero values ("val"), ptr to col indices
// ("col_ind"), ptr to row locations in val array ("row_ind")
// (these two may be swapped, not sure about the naming convention
// here...), array of actual values ("val") (I guess... '*sa'...),
// rhs, solution)
Opm::LinearSolverInterface::LinearSolverReport rep
= linsolver_.solve(matr.rows(), matr.nonZeros(),
matr.outerIndexPtr(), matr.innerIndexPtr(), matr.valuePtr(),
residual.value().data(), du.data());
if (verbose_ > 2) {
std::cout << " solveForUpdate: Linear solver took: " << clock.secsSinceLast() << " seconds." << std::endl;
}
if (!rep.converged) {
OPM_THROW(std::runtime_error, "Linear solver convergence failure.");
}
return du;
}
// ----------------- Main program -----------------
int
main(int argc, char** argv)
try
{
using namespace Opm;
if (argc <= 1) {
usage();
exit(1);
}
const char* eclipseFilename = argv[1];
EclipseStateConstPtr eclState;
ParserPtr parser(new Opm::Parser);
Opm::ParseContext parseContext({{ ParseContext::PARSE_RANDOM_SLASH , InputError::IGNORE },
{ ParseContext::PARSE_UNKNOWN_KEYWORD, InputError::IGNORE},
{ ParseContext::PARSE_RANDOM_TEXT, InputError::IGNORE},
{ ParseContext::UNSUPPORTED_SCHEDULE_GEO_MODIFIER, InputError::IGNORE},
{ ParseContext::UNSUPPORTED_COMPORD_TYPE, InputError::IGNORE},
{ ParseContext::UNSUPPORTED_INITIAL_THPRES, InputError::IGNORE},
{ ParseContext::INTERNAL_ERROR_UNINITIALIZED_THPRES, InputError::IGNORE}
});
Opm::DeckConstPtr deck(parser->parseFile(eclipseFilename, parseContext));
eclState.reset(new EclipseState(deck, parseContext));
GridManager gm(deck);
const UnstructuredGrid& grid = *gm.c_grid();
using boost::filesystem::path;
path fpath(eclipseFilename);
std::string baseName;
if (boost::to_upper_copy(path(fpath.extension()).string())== ".DATA") {
baseName = path(fpath.stem()).string();
} else {
baseName = path(fpath.filename()).string();
}
std::string logFile = baseName + ".SATFUNCLOG";
Opm::time::StopWatch timer;
timer.start();
RelpermDiagnostics diagnostic(logFile);
diagnostic.diagnosis(eclState, deck, grid);
timer.stop();
double tt = timer.secsSinceStart();
std::cout << "relperm diagnostics: " << tt << " seconds." << std::endl;
}
catch (const std::exception &e) {
std::cerr << "Program threw an exception: " << e.what() << "\n";
throw;
}
void test_flowsolver(const GI& g, const RI& r, double tol, int kind)
{
typedef typename GI::CellIterator CI;
typedef typename CI::FaceIterator FI;
typedef double (*SolutionFuncPtr)(const Vec&);
//typedef Opm::BasicBoundaryConditions<true, false> FBC;
typedef Opm::FunctionBoundaryConditions<SolutionFuncPtr> FBC;
typedef Opm::IncompFlowSolverHybrid<GI, RI, FBC,
Opm::MimeticIPEvaluator> FlowSolver;
FlowSolver solver;
// FBC flow_bc;
// assign_bc(g, flow_bc);
FBC flow_bc(&u);
typename CI::Vector gravity(0.0);
std::cout << "========== Init pressure solver =============" << std::endl;
Opm::time::StopWatch rolex;
rolex.start();
solver.init(g, r, gravity, flow_bc);
rolex.stop();
std::cout << "========== Time in seconds: " << rolex.secsSinceStart() << " =============" << std::endl;
std::vector<double> src(g.numberOfCells(), 0.0);
assign_src(g, src);
std::vector<double> sat(g.numberOfCells(), 0.0);
std::cout << "========== Starting pressure solve =============" << std::endl;
rolex.start();
solver.solve(r, sat, flow_bc, src, tol, 3, kind);
rolex.stop();
std::cout << "========== Time in seconds: " << rolex.secsSinceStart() << " =============" << std::endl;
typedef typename FlowSolver::SolutionType FlowSolution;
FlowSolution soln = solver.getSolution();
std::vector<typename GI::Vector> cell_velocity;
estimateCellVelocity(cell_velocity, g, solver.getSolution());
// Dune's vtk writer wants multi-component data to be flattened.
std::vector<double> cell_velocity_flat(&*cell_velocity.front().begin(),
&*cell_velocity.back().end());
std::vector<double> cell_pressure;
getCellPressure(cell_pressure, g, soln);
compare_pressure(g, cell_pressure);
Dune::VTKWriter<typename GI::GridType::LeafGridView> vtkwriter(g.grid().leafView());
vtkwriter.addCellData(cell_velocity_flat, "velocity", GI::GridType::dimension);
vtkwriter.addCellData(cell_pressure, "pressure");
vtkwriter.write("testsolution-" + boost::lexical_cast<std::string>(0),
Dune::VTKOptions::ascii);
}
SimulatorReport AdaptiveTimeStepping::
stepImpl( const SimulatorTimer& simulatorTimer,
Solver& solver, State& state, WState& well_state,
Output* outputWriter )
{
SimulatorReport report;
const double timestep = simulatorTimer.currentStepLength();
// init last time step as a fraction of the given time step
if( suggested_next_timestep_ < 0 ) {
suggested_next_timestep_ = restart_factor_ * timestep;
}
if (full_timestep_initially_) {
suggested_next_timestep_ = timestep;
}
// TODO
// take change in well state into account
// create adaptive step timer with previously used sub step size
AdaptiveSimulatorTimer substepTimer( simulatorTimer, suggested_next_timestep_, max_time_step_ );
// copy states in case solver has to be restarted (to be revised)
State last_state( state );
WState last_well_state( well_state );
// counter for solver restarts
int restarts = 0;
// sub step time loop
while( ! substepTimer.done() )
{
// get current delta t
const double dt = substepTimer.currentStepLength() ;
if( timestep_verbose_ )
{
std::ostringstream ss;
ss <<" Substep " << substepTimer.currentStepNum() << ", stepsize "
<< unit::convert::to(substepTimer.currentStepLength(), unit::day) << " days.";
OpmLog::info(ss.str());
}
SimulatorReport substepReport;
try {
substepReport = solver.step( substepTimer, state, well_state);
report += substepReport;
if( solver_verbose_ ) {
// report number of linear iterations
OpmLog::note("Overall linear iterations used: " + std::to_string(substepReport.total_linear_iterations));
}
}
catch (const Opm::NumericalProblem& e) {
detail::logException(e, solver_verbose_);
// since linearIterations is < 0 this will restart the solver
}
catch (const std::runtime_error& e) {
detail::logException(e, solver_verbose_);
// also catch linear solver not converged
}
catch (const Dune::ISTLError& e) {
detail::logException(e, solver_verbose_);
// also catch errors in ISTL AMG that occur when time step is too large
}
catch (const Dune::MatrixBlockError& e) {
detail::logException(e, solver_verbose_);
// this can be thrown by ISTL's ILU0 in block mode, yet is not an ISTLError
}
if( substepReport.converged )
{
// advance by current dt
++substepTimer;
// create object to compute the time error, simply forwards the call to the model
detail::SolutionTimeErrorSolverWrapper< Solver, State >
relativeChange( solver, last_state, state );
// compute new time step estimate
double dtEstimate =
timeStepControl_->computeTimeStepSize( dt, substepReport.total_linear_iterations, relativeChange, substepTimer.simulationTimeElapsed());
// limit the growth of the timestep size by the growth factor
dtEstimate = std::min( dtEstimate, double(max_growth_ * dt) );
// further restrict time step size growth after convergence problems
if( restarts > 0 ) {
dtEstimate = std::min( growth_factor_ * dt, dtEstimate );
// solver converged, reset restarts counter
restarts = 0;
}
if( timestep_verbose_ )
{
std::ostringstream ss;
ss << " Substep summary: ";
if (report.total_well_iterations != 0) {
ss << "well iterations = " << report.total_well_iterations << ", ";
}
ss << "newton iterations = " << report.total_newton_iterations << ", "
<< "linearizations = " << report.total_linearizations
<< " (" << report.assemble_time << " sec), "
<< "linear iterations = " << report.total_linear_iterations
<< " (" << report.linear_solve_time << " sec)";
OpmLog::info(ss.str());
}
// write data if outputWriter was provided
// if the time step is done we do not need
// to write it as this will be done by the simulator
// anyway.
if( outputWriter && !substepTimer.done() ) {
Opm::time::StopWatch perfTimer;
perfTimer.start();
bool substep = true;
const auto& physicalModel = solver.model();
outputWriter->writeTimeStep( substepTimer, state, well_state, physicalModel, substep);
report.output_write_time += perfTimer.secsSinceStart();
}
// set new time step length
substepTimer.provideTimeStepEstimate( dtEstimate );
// update states
last_state = state ;
last_well_state = well_state;
report.converged = substepTimer.done();
}
else // in case of no convergence (linearIterations < 0)
{
report.converged = false;
// increase restart counter
if( restarts >= solver_restart_max_ ) {
const auto msg = std::string("Solver failed to converge after ")
+ std::to_string(restarts) + " restarts.";
if (solver_verbose_) {
OpmLog::error(msg);
}
OPM_THROW_NOLOG(Opm::NumericalProblem, msg);
}
const double newTimeStep = restart_factor_ * dt;
// we need to revise this
substepTimer.provideTimeStepEstimate( newTimeStep );
if( solver_verbose_ ) {
std::string msg;
msg = "Solver convergence failed, restarting solver with new time step ("
+ std::to_string(unit::convert::to( newTimeStep, unit::day )) + " days).\n";
OpmLog::problem(msg);
}
// reset states
state = last_state;
well_state = last_well_state;
++restarts;
}
}
// store estimated time step for next reportStep
suggested_next_timestep_ = substepTimer.currentStepLength();
if( timestep_verbose_ )
{
std::ostringstream ss;
substepTimer.report(ss);
ss << "Suggested next step size = " << unit::convert::to( suggested_next_timestep_, unit::day ) << " (days)" << std::endl;
OpmLog::note(ss.str());
}
if( ! std::isfinite( suggested_next_timestep_ ) ) { // check for NaN
suggested_next_timestep_ = timestep;
}
return report;
}
//! \brief Main driver
int main(int argc, char** argv)
try
{
try {
static const int dim = 3;
typedef Dune::CpGrid GridType;
if (argc < 2 || strcmp(argv[1],"-h") == 0
|| strcmp(argv[1],"--help") == 0
|| strcmp(argv[1],"-?") == 0) {
syntax(argv);
exit(1);
}
Params p;
parseCommandLine(argc,argv,p);
Opm::time::StopWatch watch;
watch.start();
GridType grid;
if (p.file == "uniform") {
std::array<int,3> cells;
cells[0] = p.cellsx;
cells[1] = p.cellsy;
cells[2] = p.cellsz;
std::array<double,3> cellsize;
cellsize[0] = cellsize[1] = cellsize[2] = 1.f;
grid.createCartesian(cells,cellsize);
} else
grid.readEclipseFormat(p.file,p.ctol,false);
typedef GridType::ctype ctype;
Opm::Elasticity::ElasticityUpscale<GridType> upscale(grid, p.ctol,
p.Emin, p.file,
p.rocklist,
p.verbose);
if (p.max[0] < 0 || p.min[0] < 0) {
std::cout << "determine side coordinates..." << std::endl;
upscale.findBoundaries(p.min,p.max);
std::cout << " min " << p.min[0] << " " << p.min[1] << " " << p.min[2] << std::endl;
std::cout << " max " << p.max[0] << " " << p.max[1] << " " << p.max[2] << std::endl;
}
if (p.n1 == -1 || p.n2 == -1) {
p.n1 = grid.logicalCartesianSize()[0];
p.n2 = grid.logicalCartesianSize()[1];
}
if (p.linsolver.zcells == -1) {
double lz = p.max[2]-p.min[2];
int nz = grid.logicalCartesianSize()[2];
double hz = lz/nz;
double lp = sqrt((double)(p.max[0]-p.min[0])*(p.max[1]-p.min[1]));
int np = std::max(grid.logicalCartesianSize()[0],
grid.logicalCartesianSize()[1]);
double hp = lp/np;
p.linsolver.zcells = (int)(2*hp/hz+0.5);
}
std::cout << "logical dimension: " << grid.logicalCartesianSize()[0]
<< "x" << grid.logicalCartesianSize()[1]
<< "x" << grid.logicalCartesianSize()[2]
<< std::endl;
if (p.method == UPSCALE_MPC) {
std::cout << "using MPC couplings in all directions..." << std::endl;
upscale.periodicBCs(p.min, p.max);
std::cout << "preprocessing grid..." << std::endl;
upscale.A.initForAssembly();
} else if (p.method == UPSCALE_MORTAR) {
std::cout << "using Mortar couplings.." << std::endl;
upscale.periodicBCsMortar(p.min, p.max, p.n1, p.n2,
p.lambda[0], p.lambda[1]);
} else if (p.method == UPSCALE_NONE) {
std::cout << "no periodicity approach applied.." << std::endl;
upscale.fixCorners(p.min, p.max);
upscale.A.initForAssembly();
}
Dune::FieldMatrix<double,6,6> C;
Dune::VTKWriter<GridType::LeafGridView>* vtkwriter=0;
if (!p.vtufile.empty())
vtkwriter = new Dune::VTKWriter<GridType::LeafGridView>(grid.leafView());
Opm::Elasticity::Vector field[6];
std::cout << "assembling elasticity operator..." << "\n";
upscale.assemble(-1,true);
std::cout << "setting up linear solver..." << std::endl;
upscale.setupSolvers(p.linsolver);
//#pragma omp parallel for schedule(static)
for (int i=0; i<6; ++i) {
std::cout << "processing case " << i+1 << "..." << std::endl;
std::cout << "\tassembling load vector..." << std::endl;
upscale.assemble(i,false);
std::cout << "\tsolving..." << std::endl;
upscale.solve(i);
upscale.A.expandSolution(field[i],upscale.u[i]);
#define CLAMP(x) (fabs(x)<1.e-4?0.0:x)
for (size_t j=0; j<field[i].size(); ++j) {
double val = field[i][j];
field[i][j] = CLAMP(val);
}
Dune::FieldVector<double,6> v;
upscale.averageStress(v,upscale.u[i],i);
for (int j=0; j<6; ++j)
C[i][j] = CLAMP(v[j]);
}
for (int i=0; i<6; ++i) {
std::stringstream str;
str << "sol " << i+1;
if (vtkwriter)
vtkwriter->addVertexData(field[i], str.str().c_str(), dim);
}
if (vtkwriter) {
vtkwriter->write(p.vtufile);
delete vtkwriter;
}
// voigt notation
for (int j=0; j<6; ++j)
std::swap(C[3][j],C[5][j]);
for (int j=0; j<6; ++j)
std::swap(C[j][3],C[j][5]);
std::cout << "---------" << std::endl;
std::cout << C << std::endl;
if (!p.output.empty()) {
writeOutput(p,watch,grid.size(0),upscale.volumeFractions,C);
}
return 0;
}
catch (Dune::Exception &e) {
std::cerr << "Dune reported error: " << e << std::endl;
}
catch (...) {
std::cerr << "Unknown exception thrown!" << std::endl;
}
return 1;
}
catch (const std::exception &e) {
std::cerr << "Program threw an exception: " << e.what() << "\n";
throw;
}
//! \brief Write a log of the simulation to a text file
void writeOutput(const Params& p, Opm::time::StopWatch& watch, int cells,
const std::vector<double>& volume,
const Dune::FieldMatrix<double,6,6>& C)
{
// get current time
time_t rawtime;
struct tm* timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);
// get hostname
char hostname[1024];
gethostname(hostname,1024);
std::string method = "mortar";
if (p.method == UPSCALE_MPC)
method = "mpc";
if (p.method == UPSCALE_NONE)
method = "none";
// write log
std::ofstream f;
f.open(p.output.c_str());
f << "######################################################################" << std::endl
<< "# Results from upscaling elastic moduli." << std::endl
<< "#" << std::endl
<< "# Finished: " << asctime(timeinfo)
<< "# Hostname: " << hostname << std::endl
<< "#" << std::endl
<< "# Upscaling time: " << watch.secsSinceStart() << " secs" << std::endl
<< "#" << std::endl;
if (p.file == "uniform") {
f << "# Uniform grid used" << std::endl
<< "#\t cells: " << p.cellsx*p.cellsy*p.cellsz << std::endl;
}
else {
f << "# Eclipse file: " << p.file << std::endl
<< "#\t cells: " << cells << std::endl;
}
f << "#" << std::endl;
if (!p.rocklist.empty()) {
f << "# Rock list: " << p.rocklist << std::endl
<< "#" << std::endl;
}
f << "# Options used:" << std::endl
<< "#\t method: " << method << std::endl
<< "#\t linsolver_type: " << (p.linsolver.type==Opm::Elasticity::DIRECT?"direct":"iterative")
<< std::endl;
if (p.linsolver.type == Opm::Elasticity::ITERATIVE)
f << "#\t ltol: " << p.linsolver.tol << std::endl;
if (p.file == "uniform") {
f << "#\t cellsx: " << p.cellsx << std::endl
<< "#\t cellsy: " << p.cellsy << std::endl
<< "#\t cellsz: " << p.cellsz << std::endl;
}
f << "#" << std::endl
<<"# Materials: " << volume.size() << std::endl;
for (size_t i=0; i<volume.size(); ++i)
f << "#\t Material" << i+1 << ": " << volume[i]*100 << "%" << std::endl;
f << "#" << std::endl
<< "######################################################################" << std::endl
<< C << std::endl;
}
bool EulerUpstreamImplicit<GI, RP, BC>::transportSolve(std::vector<double>& saturation,
const double time,
const typename GI::Vector& /* gravity */,
const PressureSolution& pressure_sol,
const Opm::SparseVector<double>& /* injection_rates */) const
{
Opm::ReservoirState<2> state(mygrid_.c_grid());
{
std::vector<double>& sat = state.saturation();
for (int i=0; i < mygrid_.numCells(); ++i){
sat[2*i] = saturation[i];
sat[2*i+1] = 1-saturation[i];
}
}
//int count=0;
const UnstructuredGrid* cgrid = mygrid_.c_grid();
int numhf = cgrid->cell_facepos[cgrid->number_of_cells];
std::vector<double> faceflux(numhf);
for (int c = 0, i = 0; c < cgrid->number_of_cells; ++c){
for (; i < cgrid->cell_facepos[c + 1]; ++i) {
int f= cgrid->cell_faces[i];
double outflux = pressure_sol.outflux(i);
double sgn = 2.0*(cgrid->face_cells[2*f + 0] == c) - 1;
faceflux[f] = sgn * outflux;
}
}
int num_db=direclet_hfaces_.size();
std::vector<double> sflux(num_db);
for (int i=0; i < num_db;++i){
sflux[i]=-pressure_sol.outflux(direclet_hfaces_[i]);
}
state.faceflux()=faceflux;
double dt_transport = time;
int nr_transport_steps = 1;
Opm::time::StopWatch clock;
int repeats = 0;
bool finished = false;
clock.start();
TwophaseFluid myfluid(myrp_);
double* tmp_grav=0;
const UnstructuredGrid& c_grid=*mygrid_.c_grid();
TransportModel model(myfluid,c_grid,porevol_,tmp_grav);
model.makefhfQPeriodic(periodic_faces_,periodic_hfaces_, periodic_nbfaces_);
model.initGravityTrans(*mygrid_.c_grid(),htrans_);
TransportSolver tsolver(model);
LinearSolver linsolve_;
Opm::ImplicitTransportDetails::NRReport rpt_;
Opm::TransportSource tsrc;//create_transport_source(0, 2);
// the input flux is assumed to be the saturation times the flux in the transport solver
tsrc.nsrc =direclet_cells_.size();
tsrc.saturation = direclet_sat_;
tsrc.cell = direclet_cells_;
tsrc.flux = sflux;
while (!finished) {
for (int q = 0; q < nr_transport_steps; ++q) {
tsolver.solve(*mygrid_.c_grid(), &tsrc, dt_transport, ctrl_, state, linsolve_, rpt_);
if(rpt_.flag<0){
break;
}
}
if(!(rpt_.flag<0) ){
finished =true;
}else{
if(repeats >max_repeats_){
finished=true;
}else{
OPM_MESSAGE("Warning: Transport failed, retrying with more steps.");
nr_transport_steps *= 2;
dt_transport = time/nr_transport_steps;
if (ctrl_.verbosity){
std::cout << "Warning: Transport failed, retrying with more steps. dt = "
<< dt_transport/Opm::unit::year << " year.\n";
}
std::vector<double>& sat = state.saturation();
for (int i=0; i < mygrid_.numCells(); ++i){
sat[2*i] = saturation[i];
sat[2*i+1] = 1-saturation[i];
}
}
}
repeats +=1;
}
clock.stop();
std::cout << "EulerUpstreamImplicite used " << repeats
<< " repeats and " << nr_transport_steps <<" steps"<< std::endl;
#ifdef VERBOSE
std::cout << "Seconds taken by transport solver: " << clock.secsSinceStart() << std::endl;
#endif // VERBOSE
{
std::vector<double>& sat = state.saturation();
for (int i=0; i < mygrid_.numCells(); ++i){
saturation[i] = sat[2*i];
}
}
if((rpt_.flag<0)){
std::cerr << "EulerUpstreamImplicit did not converge" << std::endl;
return false;
}else{
return true;
}
}
CollOfScalar EquelleRuntimeCUDA::newtonSolve(const ResidualFunctor& rescomp,
const CollOfScalar& u_initialguess)
{
Opm::time::StopWatch clock;
clock.start();
// Set up Newton loop.
// Define the primary variable
CollOfScalar u = CollOfScalar(u_initialguess, true);
if (verbose_ > 2) {
output("Initial u", u);
output(" newtonSolve: norm (initial u)", twoNorm(u));
}
CollOfScalar residual = rescomp(u);
if (verbose_ > 2) {
output("Initial residual", residual);
output(" newtonSolve: norm (initial residual)", twoNorm(residual));
}
int iter = 0;
// Debugging output not specified in Equelle.
if (verbose_ > 1) {
std::cout << " newtonSolve: iter = " << iter << " (max = " << max_iter_
<< "), norm(residual) = " << twoNorm(residual)
<< " (tol = " << abs_res_tol_ << ")" << std::endl;
}
CollOfScalar du;
// Execute newton loop until residual is small or we have used too many iterations.
while ( (twoNorm(residual) > abs_res_tol_) && (iter < max_iter_) ) {
if ( solver_.getSolver() == CPU ) {
du = serialSolveForUpdate(residual);
}
else {
// Solve linear equations for du, apply update.
du = solver_.solve(residual.derivative(),
residual.value(),
verbose_);
}
// du is a constant, hence, u is still a primary variable with an identity
// matrix as its derivative.
u = u - du;
// Recompute residual.
residual = rescomp(u);
if (verbose_ > 2) {
// Debugging output not specified in Equelle.
output("u", u);
output(" newtonSolve: norm(u)", twoNorm(u));
output("residual", residual);
output(" newtonSolve: norm(residual)", twoNorm(residual));
}
++iter;
// Debugging output not specified in Equelle.
if (verbose_ > 1) {
std::cout << " newtonSolve: iter = " << iter << " (max = " << max_iter_
<< "), norm(residual) = " << twoNorm(residual)
<< " (tol = " << abs_res_tol_ << ")" << std::endl;
}
}
if (verbose_ > 0) {
if (twoNorm(residual) > abs_res_tol_) {
std::cout << "Newton solver failed to converge in " << max_iter_ << " iterations" << std::endl;
} else {
std::cout << "Newton solver converged in " << iter << " iterations" << std::endl;
}
}
if (verbose_ > 1) {
std::cout << "Newton solver took: " << clock.secsSinceLast() << " seconds." << std::endl;
}
return CollOfScalar(u.value());
}
void buildFaceIndices()
{
#ifdef VERBOSE
std::cout << "Building unique face indices... " << std::flush;
Opm::time::StopWatch clock;
clock.start();
#endif
typedef CellIterator CI;
typedef typename CI::FaceIterator FI;
// We build the actual cell to face mapping in two passes.
// [code mostly lifted from IncompFlowSolverHybrid::enumerateGridDof(),
// but with a twist: This code builds a mapping from cells in index
// order to unique face numbers, while the mapping built in the
// enumerateGridDof() method was ordered by cell iterator order]
// Allocate and reserve structures.
const int nc = numberOfCells();
std::vector<int> cell(nc, -1);
std::vector<int> num_faces(nc); // In index order.
std::vector<int> fpos; fpos .reserve(nc + 1);
std::vector<int> num_cf; num_cf.reserve(nc); // In iterator order.
std::vector<int> faces ;
// First pass: enumerate internal faces.
int cellno = 0; fpos.push_back(0);
int tot_ncf = 0, tot_ncf2 = 0, max_ncf = 0;
for (CI c = cellbegin(); c != cellend(); ++c, ++cellno) {
const int c0 = c->index();
ASSERT((0 <= c0) && (c0 < nc) && (cell[c0] == -1));
cell[c0] = cellno;
num_cf.push_back(0);
int& ncf = num_cf.back();
for (FI f = c->facebegin(); f != c-> faceend(); ++f) {
if (!f->boundary()) {
const int c1 = f->neighbourCellIndex();
ASSERT((0 <= c1) && (c1 < nc) && (c1 != c0));
if (cell[c1] == -1) {
// Previously undiscovered internal face.
faces.push_back(c1);
}
}
++ncf;
}
num_faces[c0] = ncf;
fpos.push_back(int(faces.size()));
max_ncf = std::max(max_ncf, ncf);
tot_ncf += ncf;
tot_ncf2 += ncf * ncf;
}
ASSERT(cellno == nc);
// Build cumulative face sizes enabling direct insertion of
// face indices into cfdata later.
std::vector<int> cumul_num_faces(numberOfCells() + 1);
cumul_num_faces[0] = 0;
std::partial_sum(num_faces.begin(), num_faces.end(), cumul_num_faces.begin() + 1);
// Avoid (most) allocation(s) inside 'c' loop.
std::vector<int> l2g;
l2g.reserve(max_ncf);
std::vector<double> cfdata(tot_ncf);
int total_num_faces = int(faces.size());
// Second pass: build cell-to-face mapping, including boundary.
typedef std::vector<int>::iterator VII;
for (CI c = cellbegin(); c != cellend(); ++c) {
const int c0 = c->index();
ASSERT ((0 <= c0 ) && ( c0 < nc) &&
(0 <= cell[c0]) && (cell[c0] < nc));
const int ncf = num_cf[cell[c0]];
l2g.resize(ncf, 0);
for (FI f = c->facebegin(); f != c->faceend(); ++f) {
if (f->boundary()) {
// External, not counted before. Add new face...
l2g[f->localIndex()] = total_num_faces++;
} else {
// Internal face. Need to determine during
// traversal of which cell we discovered this
// face first, and extract the face number
// from the 'faces' table range of that cell.
// Note: std::find() below is potentially
// *VERY* expensive (e.g., large number of
// seeks in moderately sized data in case of
// faulted cells).
const int c1 = f->neighbourCellIndex();
ASSERT ((0 <= c1 ) && ( c1 < nc) &&
(0 <= cell[c1]) && (cell[c1] < nc));
int t = c0, seek = c1;
if (cell[seek] < cell[t])
std::swap(t, seek);
int s = fpos[cell[t]], e = fpos[cell[t] + 1];
VII p = std::find(faces.begin() + s, faces.begin() + e, seek);
ASSERT(p != faces.begin() + e);
l2g[f->localIndex()] = p - faces.begin();
}
}
ASSERT(int(l2g.size()) == num_faces[c0]);
std::copy(l2g.begin(), l2g.end(), cfdata.begin() + cumul_num_faces[c0]);
}
num_faces_ = total_num_faces;
max_faces_per_cell_ = max_ncf;
face_indices_.assign(cfdata.begin(), cfdata.end(),
num_faces.begin(), num_faces.end());
#ifdef VERBOSE
clock.stop();
double elapsed = clock.secsSinceStart();
std::cout << "done. Time elapsed: " << elapsed << std::endl;
#endif
}
void EulerUpstream<GI, RP, BC>::transportSolve(std::vector<double>& saturation,
const double time,
const typename GI::Vector& gravity,
const PressureSolution& pressure_sol,
const Opm::SparseVector<double>& injection_rates) const
{
// Compute the cfl time-step.
double cfl_dt = computeCflTime(saturation, time, gravity, pressure_sol);
// Compute the number of small steps to take, and the actual small timestep.
int nr_transport_steps;
if (cfl_dt > time){
nr_transport_steps = minimum_small_steps_;
} else {
double steps = std::min<double>(std::ceil(time/cfl_dt), std::numeric_limits<int>::max());
nr_transport_steps = int(steps);
nr_transport_steps = std::max(nr_transport_steps, minimum_small_steps_);
nr_transport_steps = std::min(nr_transport_steps, maximum_small_steps_);
}
double dt_transport = time/nr_transport_steps;
// Do the timestepping. The try-catch blocks are there to handle
// the situation that smallTimeStep throws, which may happen due
// to saturation out of bounds (if check_sat_ is true).
// We cannot guarantee that this does not happen, since we do not
// (yet) compute a capillary cfl condition.
// Using exception for "alternate control flow" like this is bad
// design, should rather use error return values for this.
std::vector<double> saturation_initial(saturation);
bool finished = false;
int repeats = 0;
const int max_repeats = 10;
Opm::time::StopWatch clock;
clock.start();
while (!finished) {
try {
#ifdef VERBOSE
std::cout << "Doing " << nr_transport_steps
<< " steps for saturation equation with stepsize "
<< dt_transport << " in seconds." << std::endl;
#endif // VERBOSE
for (int q = 0; q < nr_transport_steps; ++q) {
smallTimeStep(saturation,
dt_transport,
gravity,
pressure_sol,
injection_rates);
}
finished = true;
}
catch (...) {
++repeats;
if (repeats > max_repeats) {
throw;
}
OPM_MESSAGE("Warning: Transport failed, retrying with more steps.");
nr_transport_steps *= 2;
dt_transport = time/nr_transport_steps;
saturation = saturation_initial;
}
}
clock.stop();
#ifdef VERBOSE
std::cout << "Seconds taken by transport solver: " << clock.secsSinceStart() << std::endl;
#endif // VERBOSE
}
void ImplicitCapillarity<GI, RP, BC, IP>::transportSolve(std::vector<double>& saturation,
const double /*time*/,
const typename GI::Vector& gravity,
const PressureSolution& pressure_sol,
const Opm::SparseVector<double>& injection_rates) const
{
// Start a timer.
Opm::time::StopWatch clock;
clock.start();
// Compute capillary mobilities.
typedef typename RP::Mobility Mob;
int num_cells = saturation.size();
std::vector<Mob> cap_mob(num_cells);
for (int c = 0; c < num_cells; ++c) {
Mob& m = cap_mob[c];
residual_.reservoirProperties().phaseMobility(0, c, saturation[c], m.mob);
Mob mob2;
residual_.reservoirProperties().phaseMobility(1, c, saturation[c], mob2.mob);
Mob mob_tot;
mob_tot.setToSum(m, mob2);
Mob mob_totinv;
mob_totinv.setToInverse(mob_tot);
m *= mob_totinv;
m *= mob2;
ImplicitCapillarityDetails::thresholdMobility(m.mob, 1e-10); // @@TODO: User-set limit.
// std::cout << m.mob(0,0) << '\n';
}
ReservoirPropertyFixedMobility<Mob> capillary_mobilities(cap_mob);
// Set up boundary conditions.
BC cap_press_bcs(residual_.boundaryConditions());
for (int i = 0; i < cap_press_bcs.size(); ++i) {
if (cap_press_bcs.flowCond(i).isPeriodic()) {
cap_press_bcs.flowCond(i) = FlowBC(FlowBC::Periodic, 0.0);
}
}
// Compute injection rates from residual.
std::vector<double> injection_rates_residual(num_cells);
residual_.computeResidual(saturation, gravity, pressure_sol, injection_rates,
method_viscous_, method_gravity_, false,
injection_rates_residual);
for (int i = 0; i < num_cells; ++i) {
injection_rates_residual[i] = -injection_rates_residual[i];
}
// Compute capillary pressure.
// Note that the saturation is just a dummy for this call, since the mobilities are fixed.
psolver_.solve(capillary_mobilities, saturation, cap_press_bcs, injection_rates_residual,
residual_tolerance_, linsolver_verbosity_, linsolver_type_);
// Solve for constant to change capillary pressure solution by.
std::vector<double> cap_press(num_cells);
const PressureSolution& pcapsol = psolver_.getSolution();
for (CIt c = residual_.grid().cellbegin(); c != residual_.grid().cellend(); ++c) {
cap_press[c->index()] = pcapsol.pressure(c);
}
MatchSaturatedVolumeFunctor<GI, RP> functor(residual_.grid(),
residual_.reservoirProperties(),
saturation,
cap_press);
double min_cap_press = *std::min_element(cap_press.begin(), cap_press.end());
double max_cap_press = *std::max_element(cap_press.begin(), cap_press.end());
double cap_press_range = max_cap_press - min_cap_press;
double mod_low = 1e100;
double mod_high = -1e100;
Opm::bracketZero(functor, 0.0, cap_press_range, mod_low, mod_high);
const int max_iter = 40;
const double nonlinear_tolerance = 1e-12;
int iterations_used = -1;
typedef Opm::RegulaFalsi<Opm::ThrowOnError> RootFinder;
double mod_correct = RootFinder::solve(functor, mod_low, mod_high, max_iter, nonlinear_tolerance, iterations_used);
std::cout << "Moved capillary pressure solution by " << mod_correct << " after "
<< iterations_used << " iterations." << std::endl;
// saturation = functor.lastSaturations();
const std::vector<double>& sat_new = functor.lastSaturations();
for (int i = 0; i < num_cells; ++i) {
saturation[i] = (1.0 - update_relaxation_)*saturation[i] + update_relaxation_*sat_new[i];
}
// Optionally check and/or clamp results.
if (check_sat_ || clamp_sat_) {
checkAndPossiblyClampSat(saturation);
}
// Stop timer and optionally print seconds taken.
clock.stop();
#ifdef VERBOSE
std::cout << "Seconds taken by transport solver: " << clock.secsSinceStart() << std::endl;
#endif // VERBOSE
}
int main()
try
{
typedef Opm::AutoDiffBlock<double> ADB;
typedef ADB::V V;
typedef Eigen::SparseMatrix<double> S;
Opm::time::StopWatch clock;
clock.start();
const Opm::GridManager gm(3,3);//(50, 50, 10);
const UnstructuredGrid& grid = *gm.c_grid();
using namespace Opm::unit;
using namespace Opm::prefix;
// const Opm::IncompPropertiesBasic props(2, Opm::SaturationPropsBasic::Linear,
// { 1000.0, 800.0 },
// { 1.0*centi*Poise, 5.0*centi*Poise },
// 0.2, 100*milli*darcy,
// grid.dimensions, grid.number_of_cells);
// const Opm::IncompPropertiesBasic props(2, Opm::SaturationPropsBasic::Linear,
// { 1000.0, 1000.0 },
// { 1.0, 1.0 },
// 1.0, 1.0,
// grid.dimensions, grid.number_of_cells);
const Opm::IncompPropertiesBasic props(2, Opm::SaturationPropsBasic::Linear,
{ 1000.0, 1000.0 },
{ 1.0, 30.0 },
1.0, 1.0,
grid.dimensions, grid.number_of_cells);
V htrans(grid.cell_facepos[grid.number_of_cells]);
tpfa_htrans_compute(const_cast<UnstructuredGrid*>(&grid), props.permeability(), htrans.data());
V trans_all(grid.number_of_faces);
// tpfa_trans_compute(const_cast<UnstructuredGrid*>(&grid), htrans.data(), trans_all.data());
const int nc = grid.number_of_cells;
std::vector<int> allcells(nc);
for (int i = 0; i < nc; ++i) {
allcells[i] = i;
}
std::cerr << "Opm core " << clock.secsSinceLast() << std::endl;
// Define neighbourhood-derived operator matrices.
const Opm::HelperOps ops(grid);
const int num_internal = ops.internal_faces.size();
std::cerr << "Topology matrices " << clock.secsSinceLast() << std::endl;
typedef Opm::AutoDiffBlock<double> ADB;
typedef ADB::V V;
// q
V q(nc);
q.setZero();
q[0] = 1.0;
q[nc-1] = -1.0;
// s0 - this is explicit now
typedef Eigen::Array<double, Eigen::Dynamic, 2, Eigen::RowMajor> TwoCol;
TwoCol s0(nc, 2);
s0.leftCols<1>().setZero();
s0.rightCols<1>().setOnes();
// totmob - explicit as well
TwoCol kr(nc, 2);
props.relperm(nc, s0.data(), allcells.data(), kr.data(), 0);
const V krw = kr.leftCols<1>();
const V kro = kr.rightCols<1>();
const double* mu = props.viscosity();
const V totmob = krw/mu[0] + kro/mu[1];
// Moved down here because we need total mobility.
tpfa_eff_trans_compute(const_cast<UnstructuredGrid*>(&grid), totmob.data(),
htrans.data(), trans_all.data());
// Still explicit, and no upwinding!
V mobtransf(num_internal);
for (int fi = 0; fi < num_internal; ++fi) {
mobtransf[fi] = trans_all[ops.internal_faces[fi]];
}
std::cerr << "Property arrays " << clock.secsSinceLast() << std::endl;
// Initial pressure.
V p0(nc,1);
p0.fill(200*Opm::unit::barsa);
// First actual AD usage: defining pressure variable.
const std::vector<int> bpat = { nc };
// Could actually write { nc } instead of bpat below,
// but we prefer a named variable since we will repeat it.
const ADB p = ADB::variable(0, p0, bpat);
const ADB ngradp = ops.ngrad*p;
// We want flux = totmob*trans*(p_i - p_j) for the ij-face.
const ADB flux = mobtransf*ngradp;
const ADB residual = ops.div*flux - q;
std::cerr << "Construct AD residual " << clock.secsSinceLast() << std::endl;
// It's the residual we want to be zero. We know it's linear in p,
// so we just need a single linear solve. Since we have formulated
// ourselves with a residual and jacobian we do this with a single
// Newton step (hopefully easy to extend later):
// p = p0 - J(p0) \ R(p0)
// Where R(p0) and J(p0) are contained in residual.value() and
// residual.derived()[0].
#if HAVE_SUITESPARSE_UMFPACK_H
typedef Eigen::UmfPackLU<S> LinSolver;
#else
typedef Eigen::BiCGSTAB<S> LinSolver;
#endif // HAVE_SUITESPARSE_UMFPACK_H
LinSolver solver;
S pmatr;
residual.derivative()[0].toSparse(pmatr);
pmatr.coeffRef(0,0) *= 2.0;
pmatr.makeCompressed();
solver.compute(pmatr);
if (solver.info() != Eigen::Success) {
std::cerr << "Pressure/flow Jacobian decomposition error\n";
return EXIT_FAILURE;
}
// const Eigen::VectorXd dp = solver.solve(residual.value().matrix());
ADB::V residual_v = residual.value();
const V dp = solver.solve(residual_v.matrix()).array();
if (solver.info() != Eigen::Success) {
std::cerr << "Pressure/flow solve failure\n";
return EXIT_FAILURE;
}
const V p1 = p0 - dp;
std::cerr << "Solve " << clock.secsSinceLast() << std::endl;
// std::cout << p1 << std::endl;
// ------ Transport solve ------
// Now we'll try to do a transport step as well.
// Residual formula is
// R_w = s_w - s_w^0 + dt/pv * (div v_w)
// where
// v_w = f_w v
// and f_w is (for now) based on averaged mobilities, not upwind.
double res_norm = 1e100;
const V sw0 = s0.leftCols<1>();
// V sw1 = sw0;
V sw1 = 0.5*V::Ones(nc,1);
const V ndp = (ops.ngrad * p1.matrix()).array();
const V dflux = mobtransf * ndp;
const Opm::UpwindSelector<double> upwind(grid, ops, dflux);
const V pv = Eigen::Map<const V>(props.porosity(), nc, 1)
* Eigen::Map<const V>(grid.cell_volumes, nc, 1);
const double dt = 0.0005;
const V dtpv = dt/pv;
const V qneg = q.min(V::Zero(nc,1));
const V qpos = q.max(V::Zero(nc,1));
std::cout.setf(std::ios::scientific);
std::cout.precision(16);
int it = 0;
do {
const ADB sw = ADB::variable(0, sw1, bpat);
const std::vector<ADB> pmobc = phaseMobility<ADB>(props, allcells, sw.value());
const std::vector<ADB> pmobf = upwind.select(pmobc);
const ADB fw_cell = fluxFunc(pmobc);
const ADB fw_face = fluxFunc(pmobf);
const ADB flux1 = fw_face * dflux;
const ADB qtr_ad = qpos + fw_cell*qneg;
const ADB transport_residual = sw - sw0 + dtpv*(ops.div*flux1 - qtr_ad);
res_norm = transport_residual.value().matrix().norm();
std::cout << "res_norm[" << it << "] = "
<< res_norm << std::endl;
S smatr;
transport_residual.derivative()[0].toSparse(smatr);
smatr.makeCompressed();
solver.compute(smatr);
if (solver.info() != Eigen::Success) {
std::cerr << "Transport Jacobian decomposition error\n";
return EXIT_FAILURE;
}
ADB::V transport_residual_v = transport_residual.value();
const V ds = solver.solve(transport_residual_v.matrix()).array();
if (solver.info() != Eigen::Success) {
std::cerr << "Transport solve failure\n";
return EXIT_FAILURE;
}
sw1 = sw.value() - ds;
std::cerr << "Solve for s[" << it << "]: "
<< clock.secsSinceLast() << '\n';
sw1 = sw1.min(V::Ones(nc,1)).max(V::Zero(nc,1));
it += 1;
} while (res_norm > 1e-7);
std::cout << "Saturation solution:\n"
<< "function s1 = solution\n"
<< "s1 = [\n" << sw1 << "\n];\n";
}
catch (const std::exception &e) {
std::cerr << "Program threw an exception: " << e.what() << "\n";
throw;
}
int run(Params& p)
{
try {
static const int dim = 3;
Opm::time::StopWatch watch;
watch.start();
GridType grid;
if (p.file == "uniform") {
std::array<int,3> cells;
cells[0] = p.cellsx;
cells[1] = p.cellsy;
cells[2] = p.cellsz;
std::array<double,3> cellsize;
cellsize[0] = p.max[0] > -1?p.max[0]/cells[0]:1.0;
cellsize[1] = p.max[1] > -1?p.max[1]/cells[1]:1.0;
cellsize[2] = p.max[2] > -1?p.max[2]/cells[2]:1.0;
grid.createCartesian(cells,cellsize);
} else {
Opm::ParseContext parseContext;
Opm::ParserPtr parser(new Opm::Parser());
Opm::DeckConstPtr deck(parser->parseFile(p.file , parseContext));
Opm::EclipseGrid inputGrid(deck);
grid.processEclipseFormat(inputGrid, false);
}
ElasticityUpscale<GridType, AMG> upscale(grid, p.ctol, p.Emin, p.file,
p.rocklist, p.verbose);
if (p.max[0] < 0 || p.min[0] < 0) {
std::cout << "determine side coordinates..." << std::endl;
upscale.findBoundaries(p.min,p.max);
std::cout << " min " << p.min[0] << " " << p.min[1] << " " << p.min[2] << std::endl;
std::cout << " max " << p.max[0] << " " << p.max[1] << " " << p.max[2] << std::endl;
}
if (p.n1 == -1 || p.n2 == -1) {
p.n1 = grid.logicalCartesianSize()[0];
p.n2 = grid.logicalCartesianSize()[1];
}
if (p.linsolver.zcells == -1) {
double lz = p.max[2]-p.min[2];
int nz = grid.logicalCartesianSize()[2];
double hz = lz/nz;
double lp = sqrt((double)(p.max[0]-p.min[0])*(p.max[1]-p.min[1]));
int np = std::max(grid.logicalCartesianSize()[0],
grid.logicalCartesianSize()[1]);
double hp = lp/np;
p.linsolver.zcells = (int)(2*hp/hz+0.5);
}
std::cout << "logical dimension: " << grid.logicalCartesianSize()[0]
<< "x" << grid.logicalCartesianSize()[1]
<< "x" << grid.logicalCartesianSize()[2]
<< std::endl;
if (p.inspect == "mesh")
return 0;
if (p.linsolver.pre == UNDETERMINED) {
double hx = (p.max[0]-p.min[0])/grid.logicalCartesianSize()[0];
double hy = (p.max[1]-p.min[1])/grid.logicalCartesianSize()[1];
double hz = (p.max[2]-p.min[2])/grid.logicalCartesianSize()[2];
double aspect = sqrt(hx*hy)/hz;
std::cout << "Estimated cell aspect ratio: " << aspect;
if (aspect > 80) {
p.linsolver.pre = TWOLEVEL;
std::cout << " => Using two level preconditioner" << std::endl;
} else {
p.linsolver.pre = Opm::Elasticity::AMG;
std::cout << " => Using AMG preconditioner" << std::endl;
}
}
if (p.method == UPSCALE_MPC) {
std::cout << "using MPC couplings in all directions..." << std::endl;
upscale.periodicBCs(p.min, p.max);
std::cout << "preprocessing grid..." << std::endl;
upscale.A.initForAssembly();
} else if (p.method == UPSCALE_MORTAR) {
std::cout << "using Mortar couplings.." << std::endl;
upscale.periodicBCsMortar(p.min, p.max, p.n1, p.n2,
p.lambda[0], p.lambda[1]);
} else if (p.method == UPSCALE_NONE) {
std::cout << "no periodicity approach applied.." << std::endl;
upscale.fixCorners(p.min, p.max);
upscale.A.initForAssembly();
}
Dune::FieldMatrix<double,6,6> C;
Opm::Elasticity::Vector field[6];
std::cout << "assembling elasticity operator..." << "\n";
upscale.assemble(-1,true);
std::cout << "setting up linear solver..." << std::endl;
upscale.setupSolvers(p.linsolver);
if (p.inspect == "load")
Dune::storeMatrixMarket(upscale.A.getOperator(), "A.mtx");
// the uzawa solver cannot run multithreaded
#ifdef HAVE_OPENMP
if (p.linsolver.uzawa) {
std::cout << "WARNING: disabling multi-threaded solves due to uzawa" << std::endl;
omp_set_num_threads(1);
}
#endif
#pragma omp parallel for schedule(static)
for (int i=0;i<6;++i) {
std::cout << "processing case " << i+1 << "..." << std::endl;
if (p.inspect == "results") {
char temp[1024];
sprintf(temp, p.resultfilename.c_str(), "x", i+1);
Dune::loadMatrixMarket(upscale.u[i], temp);
} else {
std::cout << "\tassembling load vector..." << std::endl;
upscale.assemble(i,false);
if (p.inspect == "load") {
char temp[1024];
sprintf(temp, p.resultfilename.c_str(), "b", i+1);
Dune::storeMatrixMarket(upscale.b[i], temp);
}
std::cout << "\tsolving..." << std::endl;
upscale.solve(i);
if (p.inspect == "load") {
char temp[1024];
sprintf(temp, p.resultfilename.c_str(), "x", i+1);
Dune::storeMatrixMarket(upscale.u[i], temp);
}
}
upscale.A.expandSolution(field[i],upscale.u[i]);
#define CLAMP(x) (fabs(x)<1.e-4?0.0:x)
for (size_t j=0;j<field[i].size();++j) {
double val = field[i][j];
field[i][j] = CLAMP(val);
}
Dune::FieldVector<double,6> v;
upscale.averageStress(v,upscale.u[i],i);
for (int j=0;j<6;++j)
C[i][j] = CLAMP(v[j]);
}
if (!p.vtufile.empty()) {
Dune::VTKWriter<typename GridType::LeafGridView> vtkwriter(grid.leafGridView());
for (int i=0;i<6;++i) {
std::stringstream str;
str << "sol " << i+1;
vtkwriter.addVertexData(field[i], str.str().c_str(), dim);
}
vtkwriter.write(p.vtufile);
}
Dune::FieldVector<double,3> speeds;
if (upscale.upscaledRho > -1) {
speeds = Opm::Elasticity::waveSpeeds(C, p.dip, p.azimuth, 1.0);
std::cout << "Wave speeds: " << speeds << std::endl;
}
// voigt notation
for (int j=0;j<6;++j)
std::swap(C[3][j],C[5][j]);
for (int j=0;j<6;++j)
std::swap(C[j][3],C[j][5]);
std::cout << "---------" << std::endl;
std::cout << C << std::endl;
if (!p.output.empty())
writeOutput(p, watch, grid.size(0), upscale.volumeFractions,
upscale.bySat, C, upscale.upscaledRho, speeds);
return 0;
}
catch (Dune::Exception &e) {
throw e;
}
catch (...) {
throw;
}
return 1;
}