int svm_nu_regression_c::feasible(const SVMINT i){
// is direction i feasible to minimize the target function
// (includes which_alpha==0)
if(at_bound[i] >= shrink_const){ return 0; };
SVMFLOAT alpha;
SVMFLOAT result;
alpha=all_alphas[i];
// feasible_epsilon=-1;
if(alpha-Cneg >= - is_zero){
// alpha* at upper bound
result = -lambda_eq-lambda_nu-nabla(i);
if(result>=-feasible_epsilon){
return 0;
};
}
else if((alpha<=is_zero) && (alpha >= -is_zero)){
// lower bound active
if(is_alpha_neg(i) > 0){
result = nabla(i) + lambda_eq+lambda_nu;
}
else{
result = nabla(i)-lambda_eq+lambda_nu;
};
if(result>=-feasible_epsilon){
return 0;
};
}
else if(alpha+Cpos <= is_zero){
// alpha at upper bound
result = lambda_eq -lambda_nu- nabla(i);
if(result>=-feasible_epsilon){
return 0;
};
}
else{
// not at bound
result= abs(nabla(i)+is_alpha_neg(i)*lambda_eq+lambda_nu);
if(result<=feasible_epsilon){
return 0;
};
};
return 1;
};
SVMFLOAT svm_nu_regression_c::lambda(const SVMINT i){
// size lagrangian multiplier of the active constraint
SVMFLOAT alpha;
SVMFLOAT result = 0;
alpha=all_alphas[i];
if(alpha>is_zero){
// alpha*
if(alpha-Cneg >= - is_zero){
// upper bound active
result = -lambda_eq-lambda_nu-nabla(i);
}
else{
result = -abs(nabla(i)+lambda_eq+lambda_nu);
};
}
else if(alpha >= -is_zero){
// lower bound active
if(is_alpha_neg(i) > 0){
result = nabla(i) + lambda_eq+lambda_nu;
}
else{
result = nabla(i)-lambda_eq+lambda_nu;
};
}
else if(alpha+Cpos <= is_zero){
// upper bound active
result = lambda_eq -lambda_nu - nabla(i);
}
else{
result = -abs(nabla(i)-lambda_eq+lambda_nu);
};
return result;
};
int svm_nu_regression_c::convergence(){
long time_start = get_time();
SVMFLOAT pos_sum = 0;
SVMFLOAT neg_sum = 0;
SVMINT total=0;
SVMFLOAT alpha_sum=0;
SVMFLOAT alpha_nu_sum=0;
SVMFLOAT alpha=0;
SVMINT i;
int result=1;
// actual convergence-test
total = 0; alpha_sum=0;
SVMINT total_pos = 0;
SVMINT total_neg = 0;
for(i=0;i<examples_total;i++){
alpha = all_alphas[i];
alpha_sum += alpha;
alpha_nu_sum += abs(alpha);
if((alpha>is_zero) && (alpha-Cneg < -is_zero)){
// alpha^* => nabla = lambda_eq + lambda_nu
neg_sum += nabla(i); //sum[i];
total_neg++;
}
else if((alpha<-is_zero) && (alpha+Cpos > is_zero)){
// alpha => nabla = -lambda_eq + lambda_nu
pos_sum += nabla(i); //-sum[i];
total_pos++;
};
};
if((total_pos>0) && (total_neg > 0)){
lambda_nu = -(neg_sum/total_neg+pos_sum/total_pos)/2;
lambda_eq = -(neg_sum/total_neg-pos_sum/total_pos)/2;
if(target_count>2){
if(parameters->verbosity>=5){
cout<<"Re-estimating lambdas from WS"<<endl;
};
total_pos=0; total_neg=0;
pos_sum = 0; neg_sum = 0;
// estimate lambdas from WS
for(i=0;i<working_set_size;i++){
alpha = all_alphas[working_set[i]];
if((alpha>is_zero) && (alpha-Cneg < -is_zero)){
// alpha^* => nabla = lambda_eq + lambda_nu
neg_sum += nabla(working_set[i]);
total_neg++;
}
else if((alpha<-is_zero) && (alpha+Cpos > is_zero)){
// alpha => nabla = -lambda_eq + lambda_nu
pos_sum += nabla(working_set[i]);
total_pos++;
};
};
if((total_pos>0) && (total_neg > 0)){
lambda_nu = -(neg_sum/total_neg+pos_sum/total_pos)/2;
lambda_eq = -(neg_sum/total_neg-pos_sum/total_pos)/2;
};
if(target_count>30){
i = working_set[target_count%working_set_size];
if(parameters->verbosity>=5){
cout<<"Setting lambdas to nabla("<<i<<")"<<endl;
};
if(is_alpha_neg(i) > 0){
lambda_eq = -nabla(i);
}
else{
lambda_eq = nabla(i);
};
lambda_nu=0;
};
};
if(parameters->verbosity>= 4){
cout<<"lambda_eq = "<<lambda_eq<<endl;
cout<<"lambda_nu = "<<lambda_nu<<endl;
};
}
else{
// lambda_eq and lambda_nu are a bit harder to find:
SVMFLOAT max1=-infinity;
SVMFLOAT max2=-infinity;
SVMFLOAT max3=-infinity;
SVMFLOAT max4=-infinity;
SVMFLOAT the_nabla;
for(i=0;i<examples_total;i++){
alpha = all_alphas[i];
the_nabla = nabla(i);
if(alpha-Cneg>=-is_zero){
if(the_nabla>max4) max4 = the_nabla;
}
else if(alpha+Cpos<=is_zero){
if(the_nabla>max3) max3 = the_nabla;
}
else if((alpha <= is_zero) && (alpha>=-is_zero)){
if(is_alpha_neg(i)){
if(the_nabla>max1) max1 = the_nabla;
}
else{
if(the_nabla>max2) max2 = the_nabla;
};
};
};
// cout<<"max = ("<<max1<<", "<<max2<<", "<<max3<<", "<<max4<<endl;
if(max1==-infinity) max1=0;
if(max2==-infinity) max2=0;
if(max3==-infinity) max3=0;
if(max4==-infinity) max4=0;
lambda_eq = (max1+max3-max2-max4)/4;
lambda_nu = (max1+max2-max3-max4)/4;
// cout<<((max1+max3)/2)<<" <= lambda_eq <= "<<(-(max2+max4)/2)<<endl;
// cout<<((max1+max2)/2)<<" <= lambda_nu <= "<<(-(max3+max4)/2)<<endl;
if(parameters->verbosity>= 4){
cout<<"*** no SVs in convergence(), lambda_eq = "<<lambda_eq<<"."<<endl;
cout<<" lambda_nu = "<<lambda_nu<<"."<<endl;
};
};
// check linear constraint
if(abs(alpha_sum+sum_alpha) > convergence_epsilon){
// equality constraint violated
if(parameters->verbosity>= 3){
cout<<"alpha_sum "<<alpha_sum<<endl;
cout<<"sum_alpha "<<sum_alpha<<endl;
cout<<"No convergence: equality constraint violated: |"<<(alpha_sum+sum_alpha)<<"| >> 0"<<endl;
};
project_to_constraint();
result = 0;
};
// note: original nu is already multiplied by C in init_optimizer
if(abs(alpha_nu_sum+sum_alpha_nu-nu) > convergence_epsilon){
// equality constraint violated
if(parameters->verbosity>= 3){
cout<<"alpha_nu_sum "<<alpha_nu_sum<<endl;
cout<<"sum_alpha_nu "<<sum_alpha_nu<<endl;
cout<<"No convergence: nu-equality constraint violated: |"<<(alpha_nu_sum+sum_alpha_nu-nu)<<"| >> 0"<<endl;
};
project_to_constraint();
result = 0;
};
i=0;
while((i<examples_total) && (result != 0)){
if(lambda(i)>=-convergence_epsilon){
i++;
}
else{
result = 0;
};
};
time_convergence += get_time() - time_start;
return result;
};
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;
}