Ejemplo n.º 1
0
int
main(int argc, char **argv)
{
    int		errflag = 0;
    int		sts;
    int		c;

    __pmSetProgname(argv[0]);

    indomp = (__pmInDom_int *)&indom;

    while ((c = getopt(argc, argv, "D:")) != EOF) {
	switch (c) {

#ifdef PCP_DEBUG
	case 'D':	/* debug flag */
	    sts = __pmParseDebug(optarg);
	    if (sts < 0) {
		fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
		    pmProgname, optarg);
		errflag++;
	    }
	    else
		pmDebug |= sts;
	    break;
#endif

	case '?':
	default:
	    errflag++;
	    break;
	}
    }

    if (errflag) {
	fprintf(stderr, "Usage: %s [-D...] [a|b|c|d|...|i 1|2|3}\n", pmProgname);
	exit(1);
    }

    while (optind < argc) {
	if (strcmp(argv[optind], "a") == 0) _a(0, 1, 1);
	else if (strcmp(argv[optind], "b") == 0) _b();
	else if (strcmp(argv[optind], "c") == 0) _c();
	else if (strcmp(argv[optind], "d") == 0) _a(1, 0, 1);
	else if (strcmp(argv[optind], "e") == 0) _e(0);
	else if (strcmp(argv[optind], "f") == 0) _e(3600);
	else if (strcmp(argv[optind], "g") == 0) _g();
	else if (strcmp(argv[optind], "h") == 0) _h();
	else if (strcmp(argv[optind], "i") == 0) {
	    optind++;
	    _i(atoi(argv[optind]));
	}
	else if (strcmp(argv[optind], "j") == 0) _j();
	else
	    fprintf(stderr, "torture_cache: no idea what to do with option \"%s\"\n", argv[optind]);
	optind++;
    }

    exit(0);
}
Ejemplo n.º 2
0
/**
 * Calculates key value for cell.
 *
 * @param   Map::Cell*            cell to calculate for
 * @return  pair<double,double>   key value
 */
pair<double,double> Planner::_k(Map::Cell* u)
{
	double g = _g(u);
	double rhs = _rhs(u);
	double min = (g < rhs) ? g : rhs;
	return pair<double,double>((min + _h(_start, u) + _km), min);
}
Ejemplo n.º 3
0
/**
 * set water height h in all interior grid cells (i.e. except ghost layer) 
 * to values specified by parameter function _h
 */
void SWE_Block::setWaterHeight(float (*_h)(float, float)) {

  for(int i=nghosts; i<nx+nghosts; i++)
	for(int j=nghosts; j<ny+nghosts; j++) {
      h[i][j] =  _h(offsetX + (i-nghosts+0.5f)*dx, offsetY + (j-nghosts+0.5f)*dy);
    };

  synchWaterHeightAfterWrite();
}
Ejemplo n.º 4
0
/**
 * set water height h in all interior grid cells (i.e. except ghost layer) 
 * to values specified by parameter function _h
 */
void SWE_Block::setWaterHeight(float (*_h)(float, float)) {

  for(int i=1; i<=nx; i++)
    for(int j=1; j<=ny; j++) {
      h[i][j] =  _h(offsetX + (i-0.5f)*dx, offsetY + (j-0.5f)*dy);
    };

  synchWaterHeightAfterWrite();
}
Ejemplo n.º 5
0
void SWE::setInitialValues(float(*_h)(float, float), float _u, float _v)
{
#pragma omp parallel for
	for (int i = 0; i < nx + 2; i++)
	{
		for (int j = 0; j < ny + 2; j++)
		{
			h[li(nx + 2, i, j)] = _h((i - 0.5f) * dx, (j - 0.5f) * dy);
			hu[li(nx + 2, i, j)] = h[li(nx + 2, i, j)] * _u;
			hv[li(nx + 2, i, j)] = h[li(nx + 2, i, j)] * _v;
		}
	}
}
Ejemplo n.º 6
0
/**
 * Constructor.
 *
 * @param  Map*         map
 * @param  Map::Cell*   start cell
 * @param  Map::Cell*   goal cell
 */
Planner::Planner(Map* map, Map::Cell* start, Map::Cell* goal)
{
	// Clear lists
	_open_list.clear();
	_open_hash.clear();
	_path.clear();
	
	_km = 0;

	_map = map;
	_start = start;
	_goal = goal;
	_last = _start;

	_rhs(_goal, 0.0);

	_list_insert(_goal, pair<double,double>(_h(_start, _goal), 0));
}
Ejemplo n.º 7
0
Archivo: signal.c Proyecto: ANahr/mono
void
Mono_Posix_Stdlib_InvokeSignalHandler (int signum, void *handler)
{
	mph_sighandler_t _h = (mph_sighandler_t) handler;
	_h (signum);
}
Ejemplo n.º 8
0
inline std::size_t hash_value(const ctorTeller& t) {
    //ctorTeller::display("in const hash");
    boost::hash<const std::string&> _h;
    return _h(t.name());
}
Ejemplo n.º 9
0
/**
 * Update map.
 *
 * @param   Map::Cell*   cell to update
 * @param   double       new cost of the cell
 * @return  void
 */
void Planner::update(Map::Cell* u, double cost)
{
	if (u == _goal)
		return;

	// Update km
	_km += _h(_last, _start);
	_last = _start;

	_cell(u);

	double cost_old = u->cost;
	double cost_new = cost;
	u->cost = cost;

	Map::Cell** nbrs = u->nbrs();

	double tmp_cost_old, tmp_cost_new;
	double tmp_rhs, tmp_g;

	// Update u
	for (unsigned int i = 0; i < Map::Cell::NUM_NBRS; i++)
	{
		if (nbrs[i] != NULL)
		{
			u->cost = cost_old;
			tmp_cost_old = _cost(u, nbrs[i]);
			u->cost = cost_new;
			tmp_cost_new = _cost(u, nbrs[i]);

			tmp_rhs = _rhs(u);
			tmp_g = _g(nbrs[i]);

			if (Math::greater(tmp_cost_old, tmp_cost_new))
			{
				if (u != _goal)
				{
					_rhs(u, min(tmp_rhs, (tmp_cost_new + tmp_g)));
				}
			}
			else if (Math::equals(tmp_rhs, (tmp_cost_old + tmp_g)))
			{
				if (u != _goal)
				{
					_rhs(u, _min_succ(u).second);
				}
			}
		}
	}

	_update(u);

	// Update neighbors
	for (unsigned int i = 0; i < Map::Cell::NUM_NBRS; i++)
	{
		if (nbrs[i] != NULL)
		{
			u->cost = cost_old;
			tmp_cost_old = _cost(u, nbrs[i]);
			u->cost = cost_new;
			tmp_cost_new = _cost(u, nbrs[i]);

			tmp_rhs = _rhs(nbrs[i]);
			tmp_g = _g(u);

			if (Math::greater(tmp_cost_old, tmp_cost_new))
			{
				if (nbrs[i] != _goal)
				{
					_rhs(nbrs[i], min(tmp_rhs, (tmp_cost_new + tmp_g)));
				}
			}
			else if (Math::equals(tmp_rhs, (tmp_cost_old + tmp_g)))
			{
				if (nbrs[i] != _goal)
				{
					_rhs(nbrs[i], _min_succ(nbrs[i]).second);
				}
			}

			_update(nbrs[i]);
		}
	}
}
void peano::applications::faxen::lbf::mappings::RegularGrid2BlockVTKOutput::touchVertexFirstTime(
		peano::applications::faxen::lbf::RegularGridBlockVertex&  vertex,
		const tarch::la::Vector<DIMENSIONS,double>&  x
) {
	logTraceInWith2Arguments( "touchVertexFirstTime()", x, vertex );
	peano::applications::latticeboltzmann::blocklatticeboltzmann::services::GridManagementService::getInstance().
			loadVertex(vertex.getVertexNumber());
	std::bitset<LB_BLOCK_NUMBER_OF_CELLS>& inner(peano::applications::latticeboltzmann::blocklatticeboltzmann::services::GridManagementService::getInstance().getInner());
	tarch::la::Vector<LB_BLOCK_NUMBER_OF_CELLS*DIMENSIONS,double >& velocity(peano::applications::latticeboltzmann::blocklatticeboltzmann::services::GridManagementService::getInstance().getVelocity());
	tarch::la::Vector<DIMENSIONS,double> velocityBuffer(0.0);
	tarch::la::Vector<LB_BLOCK_NUMBER_OF_CELLS,double>& density(peano::applications::latticeboltzmann::blocklatticeboltzmann::services::GridManagementService::getInstance().getDensity());
	tarch::la::Vector<DIMENSIONS,double> position(0.0);
	tarch::la::Vector<DIMENSIONS,double> currentVertexPosition(0.0);
	int vertexIndex[TWO_POWER_D];
	int cellCounter = 0;
	int vertexCounter = 0;
	int cellNumber;

#if (DIMENSIONS == 3)
	for (int zc = 0; zc < LB_BLOCKSIZE; zc++){
		position(2) = x(2) - 0.5*LB_BLOCKSIZE*_h(2) + zc*_h(2);
#endif
		for (int yc= 0; yc < LB_BLOCKSIZE; yc++){
			position(1) = x(1) - 0.5*LB_BLOCKSIZE*_h(1) + yc*_h(1);
			for (int xc=0; xc < LB_BLOCKSIZE; xc++){
				position(0) = x(0) - 0.5*LB_BLOCKSIZE*_h(0) + xc*_h(0);

				// if the current cell is inner, plot it and its vertices
				if (inner[cellCounter]){
					logDebug("touchVertexFirstTime()", "Cell " << cellCounter << " at position " << position << "," << _h << " is an inner cell");
					// vertex plotting
					vertexCounter = 0;
#if (DIMENSIONS == 3)
					for (int zv = 0; zv < 2; zv++){
						currentVertexPosition(2) = position(2) + _h(2)*zv;
#endif
						for (int yv = 0; yv < 2; yv++){
							currentVertexPosition(1) = position(1) + _h(1)*yv;
							for (int xv = 0; xv < 2; xv++){
								currentVertexPosition(0) = position(0) + _h(0)*xv;
								// if this vertex is not already in map, put it in and plot it
								if (_vertex2IndexMap.find(currentVertexPosition) == _vertex2IndexMap.end()){
									int vertexNumber = _vertexWriter->plotVertex(currentVertexPosition);
									_vertex2IndexMap[currentVertexPosition] = vertexNumber;
									vertexIndex[vertexCounter] = vertexNumber;
									// otherwise: just get its number
								} else {
									vertexIndex[vertexCounter] = _vertex2IndexMap.find(currentVertexPosition)->second;
								}
								vertexCounter++;
							}
						}
#if (DIMENSIONS == 3)
					}
#endif

					// cell plotting
#if (DIMENSIONS == 2)
					cellNumber = _cellWriter->plotQuadrangle(vertexIndex);
#elif (DIMENSIONS == 3)
					cellNumber = _cellWriter->plotHexahedron(vertexIndex);
#else
#error "Only 2D/ 3D supported!"
#endif

					// get velocity and put it into buffer
					for (int d = 0; d < DIMENSIONS; d++){
						velocityBuffer[d] = velocity[cellCounter*DIMENSIONS+d];
					}
					_densityWriter->plotCell(cellNumber,density[cellCounter]);
					_velocityWriter->plotCell(cellNumber,velocityBuffer);

					//#if defined(Debug) && (!defined(Parallel))
					// write block id
					_blockIdWriter->plotCell(cellNumber,_blockCounter);
					//#endif
				} // end is inner cell

				cellCounter++;
			}
		}
#if (DIMENSIONS == 3)
	}
#endif

	//#if defined(Debug) && (!defined(Parallel))
	// increment blockCounter
	_blockCounter++;
	//#endif

	logTraceOutWith1Argument( "touchVertexFirstTime()", vertex );
}