void load_fields_from_fft(const CH_FFT& fft , Triangulation& T ) {
int Nb = fft.Nx();
c_array vx = fft.field_vel_x();
c_array vy = fft.field_vel_y();
c_array al = fft.field_f();
for(F_v_it vit=T.vertices_begin();
vit != T.vertices_end();
vit++) {
int nx = vit->nx.val();
int ny = vit->ny.val();
// "right" ordering
int i = ( Nb - 1 ) - ny ;
int j = nx;
// "wrong" ordering
// int i = nx;
// int j = ny;
vit->U.set( Vector_2( real(vx(i,j)) , real(vy(i,j)) ) );
vit->alpha.set( real( al(i,j) ) );
// TODO: return more fields (chem pot, pressure, force, etc)
}
return;
}
Vector_2 Vector_2::rayCrossPoint( Vector_2 v1, double angle1, Vector_2 v2, double angle2 )
{
double x1 = v1.getX();
double y1 = v1.getY();
double x2 = v2.getX();
double y2 = v2.getY();
double rx1 = cos(angle1);
double ry1 = sin(angle1);
double rx2 = cos(angle2);
double ry2 = sin(angle2);
double detA = ry1*rx2 - rx1*ry2;
if ( detA == 0 ) return Vector_2(0,0,U);
double dx = x2-x1;
double dy = y2-y1;
double lambda = ( dy*rx2 - dx*ry2 ) / detA;
return Vector_2( x1 + lambda*rx1, y1 + lambda*ry1, K );
}
void linear::vctr_to_vfield(const VectorXd& vv, const kind::f vectorf, const int comp ) {
for(F_v_it fv=T.finite_vertices_begin();
fv!=T.finite_vertices_end();
fv++) {
int index = fv->idx.val();
// TODO: define changes on each component of a vector field
if(comp==0) {
FT vvy = fv->vf(vectorf).val().y() ;
fv->vf(vectorf).set( Vector_2 ( vv[index] , vvy ) );
} else {
FT vvx = fv->vf(vectorf).val().x() ;
fv->vf(vectorf).set( Vector_2 ( vvx , vv[index] ) );
}
}
return;
}
void PreProcessor::process(double scale, double trans_x, double trans_y) {
Transformation trafo_scale(CGAL::SCALING, scale);
Transformation trafo_trans(CGAL::TRANSLATION, Vector_2(-trans_x, -trans_y));
Transformation trafo = trafo_scale * trafo_trans;
// GlobalOptions::getInstance().tree_trafo = trafo;
cout << "Transforming: " << trafo << endl;
auto it = tree->element_tree.begin();
auto it_end = tree->element_tree.end();
for(; it != it_end; ++it) {
switch((*it)->get_type()) {
case EL_POLYGON: {
Polygon_2 * p = &(static_cast<PolygonElementPtr *>(*it)->element);
for(auto poly_it = p->vertices_begin(); poly_it != p->vertices_end(); ++poly_it) {
*poly_it = poly_it->transform(trafo);
}
}
break;
case EL_FILLED_POLYGON: { // Todo transform holes!
FilledPolygonElementPtr * fp = static_cast<FilledPolygonElementPtr *>(*it);
Polygon_with_holes_2 scaled_pwh(transform(trafo, fp->element.outer_boundary()));
for(auto hit = fp->element.holes_begin(); hit != fp->element.holes_end(); ++hit) {
scaled_pwh.add_hole(transform(trafo, (*hit)));
}
cout << "Scaled PWH = " << scaled_pwh << endl;
fp->element = scaled_pwh;
}
break;
case EL_POLYLINE: {
PolyLine_P * p = &(static_cast<PolyLineElementPtr *>(*it)->element);
auto poly_it = p->begin();
auto poly_end = p->end();
for(; poly_it != poly_end; ++poly_it) {
*poly_it = poly_it->transform(trafo);
}
}
break;
}
}
if(tree->startpoint_elem) {
PolyLine_P * p = &(static_cast<PolyLineElementPtr *>(tree->startpoint_elem)->element);
auto poly_it = p->begin();
auto poly_end = p->end();
for(; poly_it != poly_end; ++poly_it) {
*poly_it = poly_it->transform(trafo);
}
}
}
vec_type Sphere::TestContour(const contour_t &cnt, VecContour<> *subcont, Vector_3 *subcenter) const{
if(subcenter)
*subcenter=0;
Vector_3 nn=cnt.GetNormVect(); // normal to contour
nn.normalize();
vec_type dist=(*(cnt.points_begin())-center)*nn; // "distance" from center of sphere to contour plane (can be negative)
vec_type r2=(R*R-dist*dist); // radius^2 of this circle forming by intersection between contour plane and sphere
if (r2<=0) return 0; // contour plane does not intersect sphere
Vector_3 c=center+dist*nn; // center of circle
Circle C(sqrt(r2),Vector_2());
Vector_3 ax,ay;
set_perpendiculars(nn,ax,ay);
Contour_3to2<contour_t> cnt2(cnt,c,ax,ay);
Vector_2 subcenter2;
vec_type area=C.TestContour(cnt2,NULL,subcenter ? &subcenter2 : NULL);
if(subcenter && area)
*subcenter=Vector_2to3(subcenter2,c,ax,ay);
return area;
}
Vector_2 Vector_2::newVectorTo( double len, double angle )
{
return Vector_2( x+len*cos(angle), y+len*sin(angle), K );
}
Vector_2 Vector_2::newLength( double len )
{
return len == 0 ? Vector_2( 0, 0, K ) : Vector_2( x/length*len, y/length*len, K );
}
Vector_2 Origin::operator-(const Point_2& p) const {return Vector_2( CGAL::ORIGIN-p.get_data() ); }
