int
AdkZhangMeritFunctionCheck::check(const Vector &u_old,
double g_old,
const Vector &grad_G_old,
double stepSize,
const Vector &stepDirection,
double g_new,
int reschk ///// added by K Fujimura /////
)
{
// Update penalty parameter 'c' (should remain constant along the search direction)
/////S added by K Fujimura /////
//this->updateMeritParameters(u_old,g_old,grad_G_old);
this->updateMeritParameters(u_old,g_old,grad_G_old,reschk);
/////E added by K Fujimura /////
// New point in standard normal space (//different from K.F.)
//Vector u_new = u_old + stepSize*stepDirection;
Vector u_new(u_old);
u_new.addVector(1.0, stepDirection, stepSize);
// Compute value of merit functions
static Vector dummy(1);
double merit_old = this->getMeritFunctionValue(u_old,g_old,dummy);
double merit_new = this->getMeritFunctionValue(u_new,g_new,dummy);
// Gradient of the merit function
double signumG;
if (g_old != 0.0) {
signumG = g_old/fabs(g_old);
}
else {
signumG = 1.0;
}
//Vector gradM_old = u_old + c * signumG * grad_G_old;
//Vector gradM_old(u_old);
//gradM_old.addVector(1.0, grad_G_old, c*signumG);
// Without forming temporary Vector object
double checkValue = u_old^stepDirection;
checkValue += c*signumG*(grad_G_old^stepDirection);
checkValue *= a*stepSize;
// Do the check
//if ( (merit_new-merit_old) <= a*stepSize*(gradM_old^stepDirection) ) {
if ( (merit_new-merit_old) <= checkValue ) {
return 0; // ok
}
else {
return -1; // not ok
}
}
static void
doit (void)
{
struct taia stamp;
struct taia deadline;
int j = 0, r = 0, iolen = 0;
for (;;)
{
taia_now (&stamp);
taia_uint (&deadline, 120);
taia_add (&deadline, &deadline, &stamp);
iolen = 0;
udp53io = io + iolen++;
udp53io->fd = udp53;
udp53io->events = IOPAUSE_READ;
tcp53io = io + iolen++;
tcp53io->fd = tcp53;
tcp53io->events = IOPAUSE_READ;
for (j = 0; j < MAXUDP; ++j)
{
if (u[j].active)
{
u[j].io = io + iolen++;
query_io (&u[j].q, u[j].io, &deadline);
}
}
for (j = 0; j < MAXTCP; ++j)
{
if (t[j].active)
{
t[j].io = io + iolen++;
if (t[j].state == 0)
query_io (&t[j].q, t[j].io, &deadline);
else
{
if (taia_less (&t[j].timeout, &deadline))
deadline = t[j].timeout;
t[j].io->fd = t[j].tcp;
t[j].io->events = (t[j].state > 0) ?
IOPAUSE_READ : IOPAUSE_WRITE;
}
}
}
iopause (io, iolen, &deadline, &stamp);
for (j = 0; j < MAXUDP; ++j)
{
if (u[j].active)
{
r = query_get (&u[j].q, u[j].io, &stamp);
if (r == -1)
u_drop (j);
if (r == 1)
u_respond (j);
}
}
for (j = 0; j < MAXTCP; ++j)
{
if (t[j].active)
{
if (t[j].io->revents)
t_timeout (j);
if (t[j].state == 0)
{
r = query_get (&t[j].q, t[j].io, &stamp);
if (r == -1)
t_drop (j);
if (r == 1)
t_respond (j);
}
else
if (t[j].io->revents || taia_less (&t[j].timeout, &stamp))
t_rw (j);
}
}
if (udp53io && udp53io->revents)
u_new();
if (tcp53io && tcp53io->revents)
t_new();
}
}
int main() {
// CGAL::Timer time;
//
// time.start();
cout << "Creating point cloud" << endl;
simu.read();
create();
if(simu.create_points()) {
// set_alpha_circle( Tp , 2);
// set_alpha_under_cos( Tp ) ;
cout << "Creating alpha field " << endl;
set_alpha_random( Tp ) ;
cout << "Numbering particles " << endl;
number(Tp);
}
// areas(Tp);
// quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
// volumes(Tp, simu.FEMp() );
// Delta(Tp);
// linear algebra(Tp);
// if(simu.create_points()) {
// nabla(Tp);
// Delta(Tp);
// }
move_info( Tp );
// /// Prev test begin
//cout << "Calculating Lapl U" << endl;
//algebra.laplacian_v(kind::UOLD,kind::LAPLU);
//FT dt=simu.dt();
//cout << "Calculating Ustar implicitely" << endl;
//algebra.ustar_inv(kind::USTAR, dt , kind::UOLD, false);
//cout << "Solving PPE" << endl;
//algebra.PPE( kind::USTAR, dt, kind:: P );
//cout << "Calculating grad p" << endl;
//algebra.gradient(kind::P, kind::GRADP);
//algebra.mass_s(kind::DIVU);
//draw();
// return 1;
/// Prev test end
#ifdef WRITE
algebra.save_matrices();
#endif
// areas(Tp);
// quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
// nabla(Tp);
// Delta(Tp);
// linear algebra(Tp);
// cout << "Calculating grad alpha" << endl;
// algebra.gradient(kind::ALPHA, kind::GRADALPHA);
const std::string particle_file("particles.dat");
draw(Tp, particle_file , true);
simu.advance_time();
simu.next_step();
// bool first_iter=true;
CGAL::Timer time;
time.start();
std::ofstream log_file;
log_file.open("main.log");
bool is_overdamped = ( simu.mu() > 1 ) ; // high or low Re
for(;
simu.current_step() <= simu.Nsteps();
simu.next_step()) {
cout
<< "Step " << simu.current_step()
<< " . Time " << simu.time()
<< " ; t step " << simu.dt()
<< endl;
FT dt=simu.dt();
FT dt2 = dt / 2.0 ;
int iter=0;
FT displ=1e10;
FT min_displ=1e10;
int min_iter=0;
const int max_iter=1; //10;
const FT max_displ= 1e-8; // < 0 : disable
// leapfrog, special first step.-
// if(simu.current_step() == 1) dt2 *= 0.5;
// dt2 *= 0.5;
move_info(Tp);
// iter loop
for( ; iter<max_iter ; iter++) {
cout << "Move iteration " << iter << " of " << max_iter << " " << endl;
// comment for no move.-
displ=move( Tp , dt2 );
cout << "Iter " << iter << " , moved avg " << displ << " to half point" << endl;
if( (displ < max_displ) && (iter !=0) ) break;
areas(Tp);
quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
nabla(Tp);
Delta(Tp);
linear algebra(Tp);
if( displ < min_displ) {
min_displ=displ;
min_iter=iter;
}
// set_forces_Kolmo(Tp);
// Reynolds number discrimination
#ifdef EXPLICIT
cout << "Calculating Ustar explicitely" << endl;
algebra.laplacian_v(kind::UOLD,kind::LAPLU);
u_star(Tp, dt2 , false );
#else
// cout << "Calculating chem pot" << endl;
// algebra.chempot(kind::ALPHA, kind::CHEMPOT);
cout << "Calculating alpha implicitely" << endl;
// partly explicit ( unstable ? ):
cout << "Calculating chem pot explicitely" << endl;
if (iter==0)
algebra.chempot( kind::ALPHA0, kind::CHEMPOT );
else
algebra.chempot( kind::ALPHA , kind::CHEMPOT );
// inner iter loop
for( int alpha_it=0 ; alpha_it < 1 ; alpha_it++) { // max_iter ; alpha_it++) {
cout << "Alpha loop iter " << alpha_it << endl;
algebra.chempot( kind::ALPHA , kind::CHEMPOT );
algebra.alpha_inv_cp(kind::ALPHA, dt2 , kind::ALPHA0 );
}
// algebra.gradient(kind::ALPHA, kind::ALPHA0); // ???
// // iterative, fully implicit (does not converge):
// int alpha_it=0;
// // inner iter loop
// for( ; alpha_it < 10 ; alpha_it++) { // max_iter ; alpha_it++) {
// cout << "Alpha loop iter " << alpha_it << endl;
// algebra.alpha_inv_cp2(kind::ALPHA, dt2 , kind::ALPHA0 );
// cout << "Calculating chem pot implicitely" << endl;
// algebra.chempot_inv(kind::ALPHA, dt2 , kind::ALPHA0 );
// }
// // draw(Tp, particle_file , true);
cout << "Settinf Ustar = force" << endl;
// algebra.ustar_is_force(kind::USTAR);
algebra.chem_pot_force();
// substract spurious overall movement.-
zero_mean_v( Tp , kind::FORCE);
#endif
cout << "Solving PPE" << endl;
// comment for no move.-
algebra.PPE( kind::FORCE , 1 , kind:: P ); // Dt set to 1
// cout << "Calculating grad p" << endl;
// // comment for no move.-
// algebra.gradient(kind::P, kind::GRADP);
algebra.u_inv_od(kind::U);
cout << "Evolving U " << endl;
// comment for no move.-
u_new( Tp , dt2 );
cout << "U evolved " << endl;
} // iter loop
// comment for no move.-
displ=move( Tp , dt );
// update_half_velocity( Tp , false );
// comment for no move.-
update_half_velocity( Tp , is_overdamped );
update_half_alpha( Tp );
areas(Tp);
quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
if(simu.current_step()%simu.every()==0)
draw(Tp, particle_file , true);
log_file
<< simu.current_step() << " "
<< simu.time() << " " ;
integrals( Tp , log_file); log_file << " ";
fidelity( Tp , log_file ); log_file << endl;
simu.advance_time();
} // time loop
time.stop();
log_file.close();
cout << "Total runtime: " << time.time() << endl;
return 0;
}
int main() {
// CGAL::Timer time;
//
// time.start();
cout << "Creating point cloud" << endl;
simu.read();
create();
if(simu.create_points()) {
// set_alpha_circle( Tp , 2);
// set_alpha_under_cos( Tp ) ;
cout << "Creating alpha field " << endl;
// set_alpha_random( Tp ) ; // better take it from mesh
set_alpha_random( Tm ) ;
cout << "Numbering particles " << endl;
number(Tp);
number(Tm);
}
// every step
areas(Tp);
quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
// just once!
linear algebra(Tm);
areas(Tm);
quad_coeffs(Tm , simu.FEMm() ); volumes(Tm, simu.FEMm() );
cout << "Setting up diff ops " << endl;
if(simu.create_points()) {
nabla(Tm);
Delta(Tm);
}
const std::string mesh_file("mesh.dat");
const std::string particle_file("particles.dat");
// step 0 draw.-
// draw(Tm, mesh_file , true);
// draw(Tp, particle_file , true);
cout << "Assigning alpha to particles " << endl;
#if defined FULL_FULL
{
Delta(Tp);
linear algebra_p(Tp);
from_mesh_full( Tm , Tp , algebra_p,kind::ALPHA);
}
#elif defined FULL_LUMPED
from_mesh_lumped( Tm , Tp , kind::ALPHA);
#elif defined FLIP
from_mesh(Tm , Tp , kind::ALPHA);
#else
from_mesh(Tm , Tp , kind::ALPHA);
#endif
cout << "Moving info" << endl;
move_info( Tm );
move_info( Tp );
// algebra.chempot( kind::ALPHA , kind::CHEMPOT );
// algebra.alpha_inv_cp(kind::ALPHA, simu.dt()/2.0 , kind::ALPHA0 );
// draw(Tm, mesh_file , true);
// draw(Tp, particle_file , true);
// /// Prev test begin
//cout << "Calculating Lapl U" << endl;
//algebra.laplacian_v(kind::UOLD,kind::LAPLU);
//FT dt=simu.dt();
//cout << "Calculating Ustar implicitely" << endl;
//algebra.ustar_inv(kind::USTAR, dt , kind::UOLD, false);
//cout << "Solving PPE" << endl;
//algebra.PPE( kind::USTAR, dt, kind:: P );
//cout << "Calculating grad p" << endl;
//algebra.gradient(kind::P, kind::GRADP);
//algebra.mass_s(kind::DIVU);
//draw();
// return 1;
/// Prev test end
#ifdef WRITE
algebra.save_matrices();
#endif
// areas(Tp);
// quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
// nabla(Tp);
// Delta(Tp);
// linear algebra(Tp);
// cout << "Calculating grad alpha" << endl;
// algebra.gradient(kind::ALPHA, kind::GRADALPHA);
draw(Tm, mesh_file , true);
draw(Tp, particle_file , true);
simu.advance_time();
simu.next_step();
// bool first_iter=true;
CGAL::Timer time;
time.start();
std::ofstream log_file;
log_file.open("main.log");
bool is_overdamped = ( simu.mu() > 1 ) ; // high or low Re
for(;
simu.current_step() <= simu.Nsteps();
simu.next_step()) {
cout
<< "Step " << simu.current_step()
<< " . Time " << simu.time()
<< " ; t step " << simu.dt()
<< endl;
FT dt=simu.dt();
FT dt2 = dt / 2.0 ;
int iter=0;
FT displ=1e10;
FT min_displ=1e10;
int min_iter=0;
const int max_iter = 10; //10;
const FT max_displ = 1e-8; // < 0 : disable
// leapfrog, special first step.-
// if(simu.current_step() == 1) dt2 *= 0.5;
// dt2 *= 0.5;
move_info(Tm);
move_info(Tp);
// cout << "Proj alpha onto mesh " << endl;
// //onto_mesh_lumped();
// #if defined FULL
// onto_mesh_full( Tp , Tm , algebra, kind::ALPHA);
// #elif defined FLIP
// flip_volumes(Tp , Tm , simu.FEMm() );
// onto_mesh_flip(Tp,Tm,simu.FEMm(),kind::ALPHA);
// #else
// onto_mesh_delta(Tp,Tm,kind::ALPHA);
// #endif
// iter loop
for( ; iter<max_iter ; iter++) {
// cout << "Projecting U from mesh " << endl;
cout << "Projecting U , alpha0 from mesh " << endl;
#if defined FULL_FULL
{
Delta(Tp);
linear algebra_p(Tp);
from_mesh_full_v(Tm, Tp, algebra_p , kind::U);
from_mesh_full (Tm, Tp, algebra_p , kind::ALPHA0);
from_mesh_full (Tm, Tp, algebra_p , kind::ALPHA);
}
#elif defined FULL_LUMPED
from_mesh_lumped_v(Tm, Tp, kind::U);
from_mesh_lumped (Tm, Tp, kind::ALPHA0);
from_mesh_lumped (Tm, Tp, kind::ALPHA);
#elif defined FLIP
from_mesh_v(Tm, Tp, kind::U);
from_mesh (Tm, Tp, kind::ALPHA0);
from_mesh (Tm, Tp, kind::ALPHA);
#else
from_mesh_v(Tm, Tp, kind::U);
from_mesh (Tm, Tp, kind::ALPHA0);
from_mesh (Tm, Tp, kind::ALPHA);
#endif
// comment for no move.-
displ=move( Tp , dt2 );
cout << "Iter " << iter << " , moved avg " << displ << " to half point" << endl;
if( displ < min_displ) {
min_displ=displ;
min_iter=iter;
}
if( (displ < max_displ) && (iter !=0) ) break;
areas(Tp);
quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
cout << "Proj U0, alpha0 onto mesh " << endl;
#if defined FULL
onto_mesh_full_v(Tp,Tm,algebra,kind::UOLD);
onto_mesh_full (Tp,Tm,algebra,kind::ALPHA0);
onto_mesh_full (Tp,Tm,algebra,kind::ALPHA);
#elif defined FLIP
flip_volumes(Tp , Tm , simu.FEMm() );
onto_mesh_flip_v(Tp,Tm,simu.FEMm(),kind::UOLD);
onto_mesh_flip (Tp,Tm,simu.FEMm(),kind::ALPHA0);
onto_mesh_flip (Tp,Tm,simu.FEMm(),kind::ALPHA);
#else
onto_mesh_delta_v(Tp,Tm,kind::UOLD);
onto_mesh_delta (Tp,Tm,kind::ALPHA0);
onto_mesh_delta (Tp,Tm,kind::ALPHA);
#endif
// Reynolds number discrimination
// #ifdef EXPLICIT
// cout << "Calculating Ustar explicitely" << endl;
// algebra.laplacian_v(kind::UOLD,kind::LAPLU);
// u_star(Tp, dt2 , false );
// #else
// cout << "Calculating chem pot" << endl;
// algebra.chempot(kind::ALPHA, kind::CHEMPOT);
// cout << "Calculating alpha implicitely" << endl;
//
// partly explicit ( unstable ? ):
cout << "Calculating chem pot explicitely" << endl;
// inner iter loop
for( int alpha_it=0 ; alpha_it < 1 ; alpha_it++) { // max_iter ; alpha_it++) {
cout << "Alpha loop iter " << alpha_it << endl;
if (iter==0)
algebra.chempot( kind::ALPHA0, kind::CHEMPOT );
else
algebra.chempot( kind::ALPHA , kind::CHEMPOT );
// algebra.chempot( kind::ALPHA , kind::CHEMPOT );
algebra.alpha_inv_cp(kind::ALPHA, dt2 , kind::ALPHA0 );
}
// algebra.gradient(kind::ALPHA, kind::ALPHA0); // ???
// // iterative, fully implicit (does not converge):
// int alpha_it=0;
// // inner iter loop
// for( ; alpha_it < 10 ; alpha_it++) { // max_iter ; alpha_it++) {
// cout << "Alpha loop iter " << alpha_it << endl;
// algebra.alpha_inv_cp2(kind::ALPHA, dt2 , kind::ALPHA0 );
// cout << "Calculating chem pot implicitely" << endl;
// algebra.chempot_inv(kind::ALPHA, dt2 , kind::ALPHA0 );
// }
// // draw(Tp, particle_file , true);
cout << "Calculating Ustar implicitely" << endl;
// algebra.ustar_inv(kind::USTAR, dt2 , kind::UOLD, false , false);
// comment for no move.-
algebra.ustar_inv_cp(kind::USTAR, dt2 , kind::UOLD, is_overdamped , false);
// substract spurious overall movement.-
zero_mean_v( Tp , kind::USTAR);
//#endif
cout << "Solving PPE" << endl;
// comment for no move.-
algebra.PPE( kind::USTAR, dt2 , kind:: P );
cout << "Calculating grad p" << endl;
// comment for no move.-
algebra.gradient(kind::P, kind::GRADP);
cout << "Evolving U " << endl;
// comment for no move.-
u_new( Tm , dt2 );
cout << "U evolved " << endl;
} // iter loop
#if defined FULL_FULL
{
Delta(Tp);
linear algebra_p(Tp);
from_mesh_full_v(Tm, Tp, algebra_p , kind::U);
from_mesh_full (Tm, Tp, algebra_p , kind::ALPHA);
}
#elif defined FULL_LUMPED
from_mesh_lumped_v(Tm, Tp, kind::U);
from_mesh_lumped (Tm, Tp, kind::ALPHA);
#elif defined FLIP
from_mesh_v(Tm, Tp, kind::U);
from_mesh (Tm, Tp, kind::ALPHA);
#else
from_mesh_v(Tm, Tp, kind::U);
from_mesh (Tm, Tp, kind::ALPHA);
#endif
// comment for no move.-
displ=move( Tp , dt );
// update_half_velocity( Tp , false );
// comment for no move.-
update_half_velocity( Tp , is_overdamped );
update_half_alpha( Tp ); // ??????
areas(Tp);
quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
cout << "Proj U_t+1 , alpha_t+1 onto mesh " << endl;
#if defined FULL
onto_mesh_full_v(Tp,Tm,algebra,kind::U);
onto_mesh_full (Tp,Tm,algebra,kind::ALPHA0);
onto_mesh_full (Tp,Tm,algebra,kind::ALPHA);
#elif defined FLIP
flip_volumes(Tp , Tm , simu.FEMm() );
onto_mesh_flip_v(Tp,Tm,simu.FEMm(),kind::U);
onto_mesh_flip (Tp,Tm,simu.FEMm(),kind::ALPHA0);
onto_mesh_flip (Tp,Tm,simu.FEMm(),kind::ALPHA);
#else
onto_mesh_delta_v(Tp,Tm,kind::U);
onto_mesh_delta (Tp,Tm,kind::ALPHA);
onto_mesh_delta (Tp,Tm,kind::ALPHA);
#endif
if(simu.current_step()%simu.every()==0) {
draw(Tm, mesh_file , true);
draw(Tp, particle_file , true);
}
log_file
<< simu.current_step() << " "
<< simu.time() << " " ;
// integrals( Tp , log_file); log_file << " ";
// fidelity( Tp , log_file ); log_file << endl;
simu.advance_time();
} // time loop
time.stop();
log_file.close();
cout << "Total runtime: " << time.time() << endl;
return 0;
}
