void Foam::DelaunayMeshTools::writeFixedPoints
(
const fileName& fName,
const Triangulation& t
)
{
OFstream str(fName);
Pout<< nl
<< "Writing fixed points to " << str.name() << endl;
for
(
typename Triangulation::Finite_vertices_iterator vit =
t.finite_vertices_begin();
vit != t.finite_vertices_end();
++vit
)
{
if (vit->fixed())
{
meshTools::writeOBJ(str, topoint(vit->point()));
}
}
}
void solve(Triangulation DT, Segment rect[],vector<Point> points)
{
map<TP,double> vertex_dist;
for (vertex_iterator vit = DT.finite_vertices_begin();vit!=DT.finite_vertices_end();vit++)
{
TP vertex_p = vit->point();
double min_dist = min_segment(rect, vertex_p);
vertex_dist[vertex_p] = min_dist;
}
for(Edge_iterator eit= DT.finite_edges_begin(); eit!=DT.finite_edges_end();eit++)
{
double min_dist = CGAL::to_double(DT.segment(eit).squared_length()/4);
TP vertex_p1 = eit->first->vertex(DT.cw(eit->second))->point();
TP vertex_p2 = eit->first->vertex(DT.ccw(eit->second))->point();
vertex_dist[vertex_p1] = std::min(vertex_dist[vertex_p1], min_dist);
vertex_dist[vertex_p2] = std::min(vertex_dist[vertex_p2], min_dist);
}
vector<double> dist;
for (std::map<TP,double>::iterator it = vertex_dist.begin();it!= vertex_dist.end(); it++)
{
dist.push_back(it->second);
}
sort(dist.begin(),dist.end());
int f,m,l;
f = time(dist[0]);
m = time(dist[points.size()/2]);
l = time(dist[points.size() - 1]);
cout<<f<<" "<<m<<" "<<l<<endl;
}
Foam::tmp<Foam::Field<Type>> filterFarPoints
(
const Triangulation& mesh,
const Field<Type>& field
)
{
tmp<Field<Type>> tNewField(new Field<Type>(field.size()));
Field<Type>& newField = tNewField.ref();
label added = 0;
label count = 0;
for
(
typename Triangulation::Finite_vertices_iterator vit =
mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
if (vit->real())
{
newField[added++] = field[count];
}
count++;
}
newField.resize(added);
return tNewField;
}
void u_new(Triangulation& T, const FT dt ) {
for(F_v_it fv=T.finite_vertices_begin();
fv!=T.finite_vertices_end();
fv++) {
// for(F_v_it fv=Tp.finite_vertices_begin();
// fv!=Tp.finite_vertices_end();
// fv++) {
Vector_2 Ustar = fv->Ustar.val() ;
Vector_2 gradp = fv->gradp.val() ;
Vector_2 U = Ustar - dt * gradp;
// relaxation mixing .-
FT alpha=simu.alpha();
Vector_2 U0=fv->U() ;
Vector_2 U_mix = alpha*U0+ (1-alpha)*U ;
fv->U.set( U_mix );
fv->Delta_U.set( U_mix - fv->Uold.val() );
}
return;
}
void update_half_velocity( Triangulation& Tp , const bool overdamped ) {
if (overdamped) return;
for(F_v_it fv=Tp.finite_vertices_begin();
fv!=Tp.finite_vertices_end();
fv++) {
Vector_2 v = fv->U();
// if (overdamped)
// fv->U.set( v );
// else {
Vector_2 v0 = fv->Uold();
// Vector_2 v_star = fv->Ustar();
fv->U.set( 2 * v - v0 );
// fv->U.set( v + v_star - v0 );
// }
}
return;
}
void Foam::DelaunayMeshTools::writeInternalDelaunayVertices
(
const fileName& instance,
const Triangulation& t
)
{
pointField internalDelaunayVertices(t.number_of_vertices());
label vertI = 0;
for
(
typename Triangulation::Finite_vertices_iterator vit =
t.finite_vertices_begin();
vit != t.finite_vertices_end();
++vit
)
{
if (vit->internalPoint())
{
internalDelaunayVertices[vertI++] = topoint(vit->point());
}
}
internalDelaunayVertices.setSize(vertI);
pointIOField internalDVs
(
IOobject
(
"internalDelaunayVertices",
instance,
t.time(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
internalDelaunayVertices
);
Info<< nl
<< "Writing " << internalDVs.name()
<< " to " << internalDVs.instance()
<< endl;
internalDVs.write();
}
void update_half_alpha( Triangulation& Tp ) {
for(F_v_it fv=Tp.finite_vertices_begin();
fv!=Tp.finite_vertices_end();
fv++) {
FT al = fv->alpha();
FT al0 = fv->alpha0();
fv->alpha.set( 2 * al - al0 );
}
return;
}
// ---------------------------------------------------------
// initialize
// ----------
// Initialize some of the attributes of the triangulation.
// ---------------------------------------------------------
void
initialize(Triangulation &triang)
{
// set vertex id.
int id = 0;
for(FVI vit = triang.finite_vertices_begin();
vit != triang.finite_vertices_end(); vit ++)
{
vit->id = id++;
vit->visited = false;
vit->bad = false;
vit->bad_neighbor = false;
}
// set cell id.
id = 0;
for(ACI cit = triang.all_cells_begin();
cit != triang.all_cells_end(); cit ++)
{
cit->id = id++;
cit->visited = false;
cit->outside = false;
cit->transp = false;
for(int id = 0 ; id < 4; id++)
{
cit->set_cocone_flag(id,false);
cit->neighbor(id)->set_cocone_flag(cit->neighbor(id)->index(cit),false);
cit->bdy[id] = false;
cit->opaque[id] = false;
for(int k = 0; k < 4; k ++)
cit->umbrella_member[id][k] = -1;
}
// set the convex hull points.
if(! triang.is_infinite(cit)) continue;
for(int i = 0; i < 4; i ++)
{
if(! triang.is_infinite(cit->vertex(i))) continue;
cit->vertex((i+1)%4)->set_convex_hull(true);
cit->vertex((i+2)%4)->set_convex_hull(true);
cit->vertex((i+3)%4)->set_convex_hull(true);
}
}
}
void Foam::DelaunayMeshTools::writeOBJ
(
const fileName& fName,
const Triangulation& t,
const indexedVertexEnum::vertexType startPointType,
const indexedVertexEnum::vertexType endPointType
)
{
OFstream str(fName);
Pout<< nl
<< "Writing points of types:" << nl;
forAllConstIter
(
HashTable<int>,
indexedVertexEnum::vertexTypeNames_,
iter
)
{
if (iter() >= startPointType && iter() <= endPointType)
{
Pout<< " " << iter.key() << nl;
}
}
Pout<< "to " << str.name() << endl;
for
(
typename Triangulation::Finite_vertices_iterator vit =
t.finite_vertices_begin();
vit != t.finite_vertices_end();
++vit
)
{
if (vit->type() >= startPointType && vit->type() <= endPointType)
{
meshTools::writeOBJ(str, topoint(vit->point()));
}
}
}
void move_info(Triangulation& T) {
for(F_v_it fv=T.finite_vertices_begin();
fv!=T.finite_vertices_end();
fv++) {
Periodic_point rr=T.periodic_point(fv);
Point r=T.point(rr); // current point
fv->alpha0.set( fv->alpha() );
fv->rold.set(r);
fv->Uold.set(fv->U());
// fv->Ustar.set(fv->U());
// fv->p.set(fv->p() + fv->pstar() );
}
return;
}
Foam::tmp<Foam::pointField> Foam::DelaunayMeshTools::allPoints
(
const Triangulation& t
)
{
tmp<pointField> tpts(new pointField(t.vertexCount(), point::max));
pointField& pts = tpts.ref();
for
(
typename Triangulation::Finite_vertices_iterator vit =
t.finite_vertices_begin();
vit != t.finite_vertices_end();
++vit
)
{
if (vit->internalOrBoundaryPoint() && !vit->referred())
{
pts[vit->index()] = topoint(vit->point());
}
}
return tpts;
}
void u_star(Triangulation& T, FT dt , bool semi ) {
for(F_v_it fv=T.finite_vertices_begin();
fv!=T.finite_vertices_end();
fv++) {
Vector_2 U0 = fv->Uold() ;
Vector_2 f;
if(semi)
f = simu.mu() * fv->laplU() - fv->gradp() + fv->force();
else
f = simu.mu() * fv->laplU() + fv->force(); // Include all forces here, but for the pressure grad!
Vector_2 Ustar = U0 + dt * f;
fv->Ustar.set(Ustar) ;
}
return;
}
FT move(Triangulation& Tp, const FT dt , FT& dd0 ) {
vector<data_kept> prev;
FT dd2=0;
bool first=false; // debug
for(F_v_it fv=Tp.finite_vertices_begin();
fv!=Tp.finite_vertices_end();
fv++) {
data_kept data(fv);
Vector_2 vel = fv->U();
Vector_2 disp = dt * vel;
Periodic_point rr=Tp.periodic_point(fv);
Point rnow=Tp.point(rr); // current point
Point r0=fv->rold(); // starting point
Point rnew= r0 + disp;
Vector_2 disp2 = per_vect(rnew,rnow);
FT rel_disp = sqrt(disp2.squared_length() ) / simu.h();
FT rel_disp0= sqrt( disp.squared_length() ) / simu.h();
if(first) {
cout
<< "r0 " << r0 << " "
<< "rnow " << rnow << " "
<< "rnew " << rnew << " "
<< "disp2 " << disp2 << " "
<< " idx " << fv->idx() << " "
<< "rel_disp " << rel_disp
<< endl ;
first=false;
}
dd2 += rel_disp;
dd0 += rel_disp0;
// cout << "New position: " << r0 ;
data.pos = per_point( rnew );
// cout << " ---> " << data.pos << endl ;
prev.push_back (data);
}
// cout << "relative displacement " << sqrt(dd2)/simu.no_of_points()/simu.h() << endl ;
dd2 /= simu.no_of_particles();
dd0 /= simu.no_of_particles();
// cout << "relative displacement " << dd2 << endl ;
Tp.clear(); // clears the triangulation !!
for(vector<data_kept>::iterator data=prev.begin();
data!=prev.end();
data++) {
// cout << "Inserting back at " << data->pos << endl ;
Vertex_handle fv=Tp.insert(data->pos);
data->restore(fv);
// return info to vertices
}
// cout << "Insertion done" << endl ;
Tp.convert_to_1_sheeted_covering();
return dd2;
}
int main() {
while(true) {
int bacteria_count;
cin >> bacteria_count;
// kill switch for application
if(bacteria_count == 0) {
break;
}
// read in boundaries of the dish
double left_border, right_border, bottom_border, top_border;
cin >> left_border >> bottom_border >> right_border >> top_border;
// collect bacteria's center information
vector<K::Point_2> bacteria_centers;
bacteria_centers.reserve(bacteria_count);
for(int i = 0; i < bacteria_count; i++) {
double bacteria_x, bacteria_y;
cin >> bacteria_x >> bacteria_y;
bacteria_centers.push_back(K::Point_2(bacteria_x, bacteria_y));
}
// create triangulation
Triangulation triang;
triang.insert(bacteria_centers.begin(), bacteria_centers.end());
// keep track of the distances for each bacteria
map<Triangulation::Point, double> distances;
//distances.reserve(bacteria_count);
// calculate initial distance: distance between the bacteria and the nearest dish boundary
for(Triangulation::Finite_vertices_iterator vertex_iter = triang.finite_vertices_begin(); vertex_iter != triang.finite_vertices_end(); ++vertex_iter) {
Triangulation::Point vertex = vertex_iter->point();
distances[vertex] = min(
min(vertex.x() - left_border, right_border - vertex.x()), // left/right minimum
min(vertex.y() - bottom_border, top_border - vertex.y()) // top/bottom minimum
);
distances[vertex] *= distances[vertex]; // square distance as we work with squared ones
}
// compute distance to other two neighbours and update distance if it is smaller
for(Triangulation::Finite_edges_iterator edge_iter = triang.finite_edges_begin(); edge_iter != triang.finite_edges_end(); ++edge_iter) {
Triangulation::Vertex_handle vertex1 = edge_iter->first->vertex(triang.cw(edge_iter->second));
Triangulation::Vertex_handle vertex2 = edge_iter->first->vertex(triang.ccw(edge_iter->second));
Triangulation::Point vertex1_point = vertex1->point();
Triangulation::Point vertex2_point = vertex2->point();
// calculate distance of the points of both vertex and half them (divide by 4 as distance is squared and 4 = 2^2)
double vertex_distance = CGAL::to_double(CGAL::squared_distance(vertex1_point, vertex2_point)) / 4;
// update distances to minimum
distances[vertex1_point] = min(distances[vertex1_point], vertex_distance);
distances[vertex2_point] = min(distances[vertex2_point], vertex_distance);
}
// now we know the minimum distance for each bacteria to another one or the borders of the dish
// extract distances into a vector and sort it
vector<double> only_distances;
only_distances.reserve(bacteria_count);
for(map<Triangulation::Point, double>::iterator iter = distances.begin(); iter != distances.end(); ++iter) {
only_distances.push_back(iter->second);
}
// sort distances
sort(only_distances.begin(), only_distances.end());
// print out information
cout << hours(only_distances[0]) << " " << hours(only_distances[bacteria_count/2]) << " " << hours(only_distances[bacteria_count - 1]) << endl;
}
}
bool Foam::conformalVoronoiMesh::distributeBackground(const Triangulation& mesh)
{
if (!Pstream::parRun())
{
return false;
}
Info<< nl << "Redistributing points" << endl;
timeCheck("Before distribute");
label iteration = 0;
scalar previousLoadUnbalance = 0;
while (true)
{
scalar maxLoadUnbalance = mesh.calculateLoadUnbalance();
if
(
maxLoadUnbalance <= foamyHexMeshControls().maxLoadUnbalance()
|| maxLoadUnbalance <= previousLoadUnbalance
)
{
// If this is the first iteration, return false, if it was a
// subsequent one, return true;
return iteration != 0;
}
previousLoadUnbalance = maxLoadUnbalance;
Info<< " Total number of vertices before redistribution "
<< returnReduce(label(mesh.number_of_vertices()), sumOp<label>())
<< endl;
const fvMesh& bMesh = decomposition_().mesh();
volScalarField cellWeights
(
IOobject
(
"cellWeights",
bMesh.time().timeName(),
bMesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
bMesh,
dimensionedScalar("weight", dimless, 1e-2),
zeroGradientFvPatchScalarField::typeName
);
meshSearch cellSearch(bMesh, polyMesh::FACE_PLANES);
labelList cellVertices(bMesh.nCells(), label(0));
for
(
typename Triangulation::Finite_vertices_iterator vit
= mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
// Only store real vertices that are not feature vertices
if (vit->real() && !vit->featurePoint())
{
pointFromPoint v = topoint(vit->point());
label cellI = cellSearch.findCell(v);
if (cellI == -1)
{
// Pout<< "findCell conformalVoronoiMesh::distribute "
// << "findCell "
// << vit->type() << " "
// << vit->index() << " "
// << v << " "
// << cellI
// << " find nearest cellI ";
cellI = cellSearch.findNearestCell(v);
}
cellVertices[cellI]++;
}
}
forAll(cellVertices, cI)
{
// Give a small but finite weight for empty cells. Some
// decomposition methods have difficulty with integer overflows in
// the sum of the normalised weight field.
cellWeights.internalField()[cI] = max
(
cellVertices[cI],
1e-2
);
}
autoPtr<mapDistributePolyMesh> mapDist = decomposition_().distribute
(
cellWeights
);
cellShapeControl_.shapeControlMesh().distribute(decomposition_);
distribute();
timeCheck("After distribute");
iteration++;
}
