void peano::applications::heatequation::timestepping::mappings::RegularGrid2ApplyRefineDeleteCriterion::touchVertexLastTime(
  peano::applications::heatequation::timestepping::RegularGridSingleStepVertex&  vertex,
  const tarch::la::Vector<DIMENSIONS,double>&  x
) {
  logTraceInWith2Arguments( "touchVertexLastTime()", x, vertex );
  // @todo Insert your code here
  logTraceOutWith1Argument( "touchVertexLastTime()", vertex );
}
Example #2
0
void peano::applications::navierstokes::prototype1::mappings::RegularGrid2MergeF::touchVertexLastTime(
  peano::applications::navierstokes::prototype1::RegularGridFluidVertexEnhancedDivFreeEulerExplicit&  vertex,
  const tarch::la::Vector<DIMENSIONS,double>&  x
) {
  logTraceInWith2Arguments( "touchVertexLastTime()", x, vertex );
  // @todo Insert your code here
  logTraceOutWith1Argument( "touchVertexLastTime()", vertex );
}
void peano::applications::puregrid::mappings::RegularGrid2SetupGrid::touchVertexFirstTime(
  peano::applications::puregrid::RegularGridVertex&  vertex,
  const tarch::la::Vector<DIMENSIONS,double>&  x
) {
  logTraceInWith2Arguments( "touchVertexFirstTime()", x, vertex );
  // @todo Insert your code here
  logTraceOutWith1Argument( "touchVertexFirstTime()", vertex );
}
void peano::applications::faxen::lbf::mappings::RegularGrid2ControlTimeStep::touchVertexLastTime(
		peano::applications::faxen::lbf::RegularGridBlockVertex&  vertex,
		const tarch::la::Vector<DIMENSIONS,double>&  x
) {
	logTraceInWith2Arguments( "touchVertexLastTime()", x, vertex );
	// @todo Insert your code here
	logTraceOutWith1Argument( "touchVertexLastTime()", vertex );
}
void peano::applications::faxen::lbf::mappings::RegularGrid2SwitchFromLB2NSE::touchVertexFirstTime(
		peano::applications::faxen::lbf::RegularGridBlockVertex&  vertex,
		const tarch::la::Vector<DIMENSIONS,double>&  x
) {
	logTraceInWith2Arguments( "touchVertexFirstTime()", x, vertex );
	//	std::cout << "touch first, vertex number: "<< vertex.getVertexNumber() << std::endl;
	logTraceOutWith1Argument( "touchVertexFirstTime()", vertex );
}
void peano::applications::faxen::lbf::mappings::RegularGrid2DynamicRefinementForSpacetreeGrid::handleCell(
  peano::applications::faxen::lbf::RegularGridBlockVertex* const vertices,
  peano::applications::faxen::lbf::RegularGridBlockCell&  cell,
  const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
  logTraceInWith2Arguments( "handleCell()", enumerator.toString(), cell );
  // @todo Insert your code here
  logTraceOut( "handleCell()" );
}
void peano::applications::navierstokes::prototype1::mappings::RegularGrid2InitialiseScenario::destroyCell(
  peano::applications::navierstokes::prototype1::RegularGridFluidVertexEnhancedDivFreeEulerExplicit const * const vertices,
  peano::applications::navierstokes::prototype1::RegularGridFluidCellEnhancedDivFreeEulerExplicit&  cell,
  const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
  logTraceInWith2Arguments( "destroyCell()", enumerator.toString(), cell );
  // @todo Insert your code here
  logTraceOut( "destroyCell()" );
}
void peano::applications::pic::demo2::mappings::RegularGrid2PlotSolution::touchVertexFirstTime(
  peano::applications::pic::demo2::RegularGridVertex&  vertex,
  const tarch::la::Vector<DIMENSIONS,double>&  x
) {
  logTraceInWith2Arguments( "touchVertexFirstTime()", x, vertex );
  // @todo Insert your code here
  plotVertex(vertex,x);
  logTraceOutWith1Argument( "touchVertexFirstTime()", vertex );
}
void peano::applications::faxen::lbf::mappings::RegularGrid2MoveParticles::destroyCell(
		peano::applications::faxen::lbf::RegularGridBlockVertex const * const vertices,
		peano::applications::faxen::lbf::RegularGridBlockCell&  cell,
		const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
	logTraceInWith2Arguments( "destroyCell()", enumerator.toString(), cell );
	// @todo Insert your code here
	logTraceOut( "destroyCell()" );
}
void peano::applications::pic::demo2::mappings::RegularGrid2PlotSolution::destroyCell(
  peano::applications::pic::demo2::RegularGridVertex const * const vertices,
  peano::applications::pic::demo2::RegularGridCell&  cell,
  const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
  logTraceInWith2Arguments( "destroyCell()", enumerator.toString(), cell );
  // @todo Insert your code here
  logTraceOut( "destroyCell()" );
}
void peano::applications::faxen::lbf::mappings::RegularGrid2ComputeRightHandSide::createCell(
		peano::applications::faxen::lbf::RegularGridBlockVertex const * const vertices,
		peano::applications::faxen::lbf::RegularGridBlockCell&  cell,
		const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
	logTraceInWith2Arguments( "createCell()", enumerator.toString(), cell );
	// @todo Insert your code here
	logTraceOutWith1Argument( "createCell()", cell );
}
void peano::applications::heatequation::timestepping::mappings::RegularGrid2RestrictRhs::handleCell(
  peano::applications::heatequation::timestepping::RegularGridSingleStepVertex* const vertices,
  peano::applications::heatequation::timestepping::RegularGridCell&  cell,
  const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
  logTraceInWith2Arguments( "handleCell()", enumerator.toString(), cell );
  // @todo Insert your code here
  logTraceOut( "handleCell()" );
}
void peano::applications::heatequation::timestepping::mappings::RegularGrid2ApplyRefineDeleteCriterion::createCell(
  peano::applications::heatequation::timestepping::RegularGridSingleStepVertex const * const vertices,
  peano::applications::heatequation::timestepping::RegularGridCell&  cell,
  const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
  logTraceInWith2Arguments( "createCell()", enumerator.toString(), cell );
  // @todo Insert your code here
  logTraceOutWith1Argument( "createCell()", cell );
}
void peano::applications::puregrid::mappings::RegularGrid2PerformOneRefinement::handleCell(
  peano::applications::puregrid::RegularGridVertex* const vertices,
  peano::applications::puregrid::RegularGridCell&  cell,
  const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
  logTraceInWith2Arguments( "handleCell()", enumerator.toString(), cell );
  // @todo Insert your code here
  logTraceOut( "handleCell()" );
}
void peano::applications::puregrid::mappings::RegularGrid2SetupGrid::createCell(
  peano::applications::puregrid::RegularGridVertex const * const vertices,
  peano::applications::puregrid::RegularGridCell&  cell,
  const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
  logTraceInWith2Arguments( "createCell()", enumerator.toString(), cell );
  // @todo Insert your code here
  logTraceOutWith1Argument( "createCell()", cell );
}
Example #16
0
void peano::applications::navierstokes::prototype1::mappings::RegularGrid2MergeF::mergeWithNeighbour(
  peano::applications::navierstokes::prototype1::RegularGridFluidVertexEnhancedDivFreeEulerExplicit& vertex, 
  const peano::applications::navierstokes::prototype1::RegularGridFluidVertexEnhancedDivFreeEulerExplicit& neighbour, 
  int fromRank) {
  logTraceInWith2Arguments( "mergeWithNeighbour()", vertex, neighbour );

  vertex.mergeF( neighbour );

  logTraceOut( "mergeWithNeighbour()" );
}
void peano::applications::navierstokes::prototype1::mappings::RegularGrid2InitialiseScenario::touchVertexFirstTime(
  peano::applications::navierstokes::prototype1::RegularGridFluidVertexEnhancedDivFreeEulerExplicit&  vertex,
  const tarch::la::Vector<DIMENSIONS,double>&  x
) {
  logTraceInWith2Arguments( "touchVertexFirstTime()", x, vertex );

  _calculateA->handleVertex(vertex);

  logTraceOutWith1Argument( "touchVertexFirstTime()", vertex );
}
void peano::applications::navierstokes::prototype1::mappings::RegularGrid2InitialiseScenario::createCell(
  peano::applications::navierstokes::prototype1::RegularGridFluidVertexEnhancedDivFreeEulerExplicit const * const vertices,
  peano::applications::navierstokes::prototype1::RegularGridFluidCellEnhancedDivFreeEulerExplicit&  cell,
  const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
  logTraceInWith2Arguments( "createCell()", enumerator.toString(), cell );

  cell.setFluidCellType(RegularGridFluidCellEnhancedDivFreeEulerExplicit::Records::INNER);

  logTraceOutWith1Argument( "createCell()", cell );
}
void peano::applications::navierstokes::prototype1::mappings::RegularGrid2InitialiseScenario::handleCell(
  peano::applications::navierstokes::prototype1::RegularGridFluidVertexEnhancedDivFreeEulerExplicit* const vertices,
  peano::applications::navierstokes::prototype1::RegularGridFluidCellEnhancedDivFreeEulerExplicit&  cell,
  const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
  logTraceInWith2Arguments( "handleCell()", enumerator.toString(), cell );

  _calculateA->accumulateA(vertices, cell, enumerator);

  logTraceOut( "handleCell()" );
}
Example #20
0
void peanoclaw::mappings::Cleanup::mergeWithWorker(
    peanoclaw::Vertex&        localVertex,
    const peanoclaw::Vertex&  receivedMasterVertex,
    const tarch::la::Vector<DIMENSIONS,double>&   x,
    const tarch::la::Vector<DIMENSIONS,double>&   h,
    int                                           level
) {
    logTraceInWith2Arguments( "mergeWithWorker(...)", localVertex.toString(), receivedMasterVertex.toString() );
    // @todo Insert your code here
    logTraceOutWith1Argument( "mergeWithWorker(...)", localVertex.toString() );
}
Example #21
0
void peanoclaw::mappings::Cleanup::ascend(
    peanoclaw::Cell * const    fineGridCells,
    peanoclaw::Vertex * const  fineGridVertices,
    const peano::grid::VertexEnumerator&          fineGridVerticesEnumerator,
    peanoclaw::Vertex * const  coarseGridVertices,
    const peano::grid::VertexEnumerator&          coarseGridVerticesEnumerator,
    peanoclaw::Cell&           coarseGridCell
) {
    logTraceInWith2Arguments( "ascend(...)", coarseGridCell.toString(), coarseGridVerticesEnumerator.toString() );
    // @todo Insert your code here
    logTraceOut( "ascend(...)" );
}
void peano::applications::navierstokes::prototype1::mappings::RegularGrid2UpdateVelocity::handleCell(
  peano::applications::navierstokes::prototype1::RegularGridFluidVertexEnhancedDivFreeEulerExplicit* const vertices,
  peano::applications::navierstokes::prototype1::RegularGridFluidCellEnhancedDivFreeEulerExplicit&  cell,
  const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
  logTraceInWith2Arguments( "handleCell()", enumerator.toString(), cell );

  _h = enumerator.getCellSize();
  assertion( !equals(_h, Vector(0.0)) );

  logTraceOut( "handleCell()" );
}
Example #23
0
void peanoclaw::mappings::Cleanup::prepareSendToMaster(
    peanoclaw::Cell&                       localCell,
    peanoclaw::Vertex *                    vertices,
    const peano::grid::VertexEnumerator&       verticesEnumerator,
    const peanoclaw::Vertex * const        coarseGridVertices,
    const peano::grid::VertexEnumerator&       coarseGridVerticesEnumerator,
    const peanoclaw::Cell&                 coarseGridCell,
    const tarch::la::Vector<DIMENSIONS,int>&   fineGridPositionOfCell
) {
    logTraceInWith2Arguments( "prepareSendToMaster(...)", localCell, verticesEnumerator.toString() );
    // @todo Insert your code here
    logTraceOut( "prepareSendToMaster(...)" );
}
Example #24
0
void peanoclaw::mappings::ValidateGrid::mergeWithWorker(
  peanoclaw::Cell&           localCell, 
  const peanoclaw::Cell&     receivedMasterCell,
  const tarch::la::Vector<DIMENSIONS,double>&  cellCentre,
  const tarch::la::Vector<DIMENSIONS,double>&  cellSize,
  int                                          level
) {
  logTraceInWith2Arguments( "mergeWithWorker(...)", localCell.toString(), receivedMasterCell.toString() );
  // @todo Insert your code here

  logInfo("", "ValidateGrid Receive on rank " << tarch::parallel::Node::getInstance().getRank());

  logTraceOutWith1Argument( "mergeWithWorker(...)", localCell.toString() );
}
void peano::applications::faxen::mappings::RegularGrid2Initialize::createCell(
		peano::applications::faxen::RegularGridVertex const * const vertices,
		peano::applications::faxen::RegularGridCell&  cell,
		const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
	logTraceInWith2Arguments( "createCell()", enumerator.toString(), cell );
	cell.setP(_PI);
	cell.setU(_UI);
	cell.setV(_VI);
	cell.setF(0.0);
	cell.setG(0.0);
	cell.setRes(0.0);
	cell.setRhs(0.0);
	logTraceOutWith1Argument( "createCell()", cell );
}
void peano::applications::faxen::lbf::mappings::RegularGrid2ControlTimeStep::handleCell(
		peano::applications::faxen::lbf::RegularGridBlockVertex* const vertices,
		peano::applications::faxen::lbf::RegularGridBlockCell&  cell,
		const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
	logTraceInWith2Arguments( "handleCell()", enumerator.toString(), cell );

	double uCell = cell.getU();
	double vCell = cell.getV();

	_umax = (_umax < fabs(uCell)) ? fabs(uCell) : _umax;
	_vmax = (_vmax < fabs(vCell)) ? fabs(vCell) : _vmax;

	logTraceOut( "handleCell()" );
}
tarch::la::Vector<3,double> tarch::plotter::griddata::regular::CartesianGridArrayWriter::getH() const {
  logTraceInWith2Arguments( "getH()", _numberOfGridPoints, _domainSize );
  tarch::la::Vector<3,double> result;
  for (int d=0; d<3; d++) {
	assertion(_numberOfGridPoints(d)>0);
	double tmp = _numberOfGridPoints(d)-1;
	if ( tarch::la::greater(tmp,0.0) ) {
      result(d) = _domainSize(d) / tmp;
	}
	else {
      result(d) = 0.0;
	}
  }
  logTraceOutWith1Argument( "getH()", result );
  return result;
}
void peano::applications::faxen::lbf::mappings::RegularGrid2ComputeRightHandSide::handleCell(
		peano::applications::faxen::lbf::RegularGridBlockVertex* const vertices,
		peano::applications::faxen::lbf::RegularGridBlockCell&  cell,
		const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
	logTraceInWith2Arguments( "handleCell()", enumerator.toString(), cell );

	double rhs_loc;
	double Fij   = cell.getF();
	double Fim1j = 2*vertices[enumerator(2)].getF1() - Fij;
	double Gij   = cell.getG();
	double Gijm1 = 2*vertices[enumerator(1)].getG0() - Gij;

	rhs_loc = ((Fij-Fim1j)/_dx+(Gij-Gijm1)/_dy)/_dt;

	cell.setRhs(rhs_loc);

	logTraceOut( "handleCell()" );
}
void peano::applications::navierstokes::prototype2::repositories::PrototypeRepositoryForSpacetreeGridArrayStackImplementation::restart(
  const tarch::la::Vector<DIMENSIONS,bool>&    evenFlags,
  const tarch::la::Vector<THREE_POWER_D,int>&  traversalOrderOfNeighbours,
  const tarch::la::Vector<DIMENSIONS,double>&  domainSize,
  const tarch::la::Vector<DIMENSIONS,double>&  domainOffset,
  int                                          domainLevel
) {
  logTraceInWith2Arguments( "restart(...)", evenFlags, traversalOrderOfNeighbours );
  #ifdef Parallel
  assertion( !tarch::parallel::Node::getInstance().isMasterProcess());
  #endif
  
  assertion( _repositoryState.getAction() == PrototypeRepositoryState::Terminate );

  _vertexStack.clear();
  _cellStack.clear();


  logTraceOut( "restart(...)" );
}
void peano::applications::faxen::lbf::mappings::RegularGrid2MoveParticles::handleCell(
		peano::applications::faxen::lbf::RegularGridBlockVertex* const vertices,
		peano::applications::faxen::lbf::RegularGridBlockCell&  cell,
		const peano::kernel::gridinterface::VertexEnumerator&  enumerator
) {
	logTraceInWith2Arguments( "handleCell()", enumerator.toString(), cell );

	tarch::la::Vector<DIMENSIONS, double> zeroPoint = enumerator.getVertexPosition(0);
	tarch::la::Vector<DIMENSIONS, double> cellSize = enumerator.getCellSize();

	// only 2D case
	_cellVertices[0] = &vertices[enumerator(0)];
	_cellVertices[1] = &vertices[enumerator(1)];
	_cellVertices[2] = &vertices[enumerator(2)];
	_cellVertices[3] = &vertices[enumerator(3)];

	peano::applications::faxen::lbf::services::ForcesService::getInstance().checkCell(_cellVertices,
			cell,zeroPoint,cellSize);

	logTraceOut( "handleCell()" );
}