C++ TDomain::grid方法代码示例

static void PrintElementEdgeRatios(TDomain& dom)
{
	int elemType = dom.domain_info().element_type();

	MultiGrid& mg = *dom.grid();

	UG_LOG("Element Edge Ratios:\n");
	for(size_t lvl = 0; lvl < mg.num_levels(); ++lvl){
		UG_LOG("  level " << lvl << ":\t");
		switch(elemType){
			case FACE:
				PrintElementEdgeRatios(mg, mg.begin<Face>(lvl),
									   mg.end<Face>(lvl), dom.position_accessor());
				break;

			case VOLUME:
				PrintElementEdgeRatios(mg, mg.begin<Volume>(lvl),
									   mg.end<Volume>(lvl), dom.position_accessor());
				break;
			default:
				UG_LOG("---\n");
				break;
		}
	}
}

static void ProjectVerticesToSphere(TDomain& dom, std::vector<number> center,
                                    number radius, number eps)
{
	static const int dim = TDomain::dim;
	typename TDomain::position_accessor_type& aaPos = dom.position_accessor();
	typename TDomain::grid_type& g = *dom.grid();

	if((int)center.size() != dim)
		UG_THROW("Expect center to be of dimension "<<dim);

	MathVector<dim> Center;
	for(int d = 0; d < dim; d++) Center[d] = center[d];

	for(VertexIterator iter = g.vertices_begin();
		iter != g.vertices_end(); ++iter)
	{
		MathVector<dim>& pos = aaPos[*iter];

		// move only vertices in eps-environment of sphere
		if(	VecDistance(pos, Center) < radius - eps ||
			VecDistance(pos, Center) > radius + eps) continue;

		// get closest point on sphere
		MathVector<dim> dir;
		VecSubtract(dir, pos, Center);
		number s, s1Out, s2Out;
		if(RaySphereIntersection(s1Out,s2Out, Center, dir, Center, radius) < 1)
			UG_THROW("No intersection found for pos "<<pos);
		if(s1Out > s2Out) s = s1Out; else s = s2Out;
		if(s <= 0) UG_THROW("Invalid scale "<<s);

		// set new pos
		VecScaleAdd(pos, 1.0, Center, s, dir);
	}
}

static bool SavePartitionMap(PartitionMap& pmap, TDomain& domain,
							 const char* filename)
{
	PROFILE_FUNC_GROUP("grid");
	if(domain.grid().get() != pmap.get_partition_handler()->grid())
	{
		UG_LOG("WARNING in SavePartitionMap: The given partition map was not"
				" created for the given domain. Aborting...\n");
		return false;
	}

	return SavePartitionMapToFile(pmap, filename, domain.position_attachment());
}

static void LoadAndRefineDomain(TDomain& domain, const char* filename,
								int numRefs)
{
	PROFILE_FUNC_GROUP("grid");
	try{
		LoadDomain(domain, filename);
	}
	UG_CATCH_THROW("LoadAndRefineDomain: Could not load domain at file: "<<filename);

	GlobalMultiGridRefiner ref(*domain.grid());
	for(int i = 0; i < numRefs; ++i)
		ref.refine();
}

static void TranslateDomain(TDomain& dom, number tx, number ty, number tz)
{
	typename TDomain::position_accessor_type& aaPos = dom.position_accessor();
	typename TDomain::grid_type& g = *dom.grid();
	vector3 t(tx, ty, tz);

	const int numCoords = TDomain::position_type::Size;
	UG_ASSERT(numCoords <= 3, "too many coordinates.");

	for(VertexIterator iter = g.vertices_begin();
		iter != g.vertices_end(); ++iter)
	{
		for(int i = 0; i < numCoords; ++i)
			aaPos[*iter][i] += t[i];
	}
}

static void RandomizeDomain(TDomain& dom, number dx, number dy, number dz)
{
	typename TDomain::position_accessor_type& aaPos = dom.position_accessor();
	typename TDomain::grid_type& g = *dom.grid();
	vector3 d(dx, dy, dz);

	const int numCoords = TDomain::position_type::Size;
	UG_ASSERT(numCoords <= 3, "too many coordinates.");

	for(VertexIterator iter = g.vertices_begin();
		iter != g.vertices_end(); ++iter)
	{
		for(int i = 0; i < numCoords; ++i)
			aaPos[*iter][i] += urand(-d[i], d[i]);
	}
}

static number GetMaxEdgeLength(TDomain& dom)
{
	typename TDomain::position_accessor_type& aaPos = dom.position_accessor();
	typename TDomain::grid_type& g = *dom.grid();

	number maxLenSq = 0;
	for(EdgeIterator eiter = g.template begin<Edge>();
		eiter != g.template end<Edge>(); ++eiter)
	{
		maxLenSq = max(maxLenSq, EdgeLengthSq(*eiter, aaPos));
	}

#ifdef UG_PARALLEL
	pcl::ProcessCommunicator com;
	number gMaxLenSq = com.allreduce(maxLenSq, PCL_RO_MAX);
	return sqrt(gMaxLenSq);
#else
	return sqrt(maxLenSq);
#endif
}

static void MinimizeMemoryFootprint(TDomain& dom)
{
	dom.grid()->set_options(GRIDOPT_VERTEXCENTRIC_INTERCONNECTION
							 | GRIDOPT_AUTOGENERATE_SIDES);
}