void peanoclaw::interSubgridCommunication::GridLevelTransfer::updatePatchStateDuringMergeWithWorker( int localCellDescriptionIndex, int remoteCellDescriptionIndex ) { logTraceInWith1Argument("updatePatchStateDuringMergeWithWorker", localCellDescriptionIndex); assertion(localCellDescriptionIndex != -1); CellDescription& localCellDescription = CellDescriptionHeap::getInstance().getData(localCellDescriptionIndex).at(0); Patch localPatch(localCellDescription); if(remoteCellDescriptionIndex != -1) { CellDescription& remoteCellDescription = CellDescriptionHeap::getInstance().getData(remoteCellDescriptionIndex).at(0); assertion1(localCellDescriptionIndex != -1, localPatch); if(remoteCellDescription.getUIndex() != -1) { assertion1(localPatch.isVirtual() || localPatch.isLeaf(), localPatch); //Delete current content of patch DataHeap::getInstance().deleteData(localPatch.getUIndex()); //Merge localCellDescription.setUIndex(remoteCellDescription.getUIndex()); } CellDescriptionHeap::getInstance().deleteData(remoteCellDescriptionIndex); } logTraceOut("updatePatchStateDuringMergeWithWorker"); }
void tarch::plotter::griddata::unstructured::vtk::VTKTextFileWriter::VertexDataWriter::plotVertex( int index, const tarch::la::Vector<2,double>& value ) { assertion(_lastWriteCommandVertexNumber>=-1); assertion(2<=_recordsPerVertex); assertion1( static_cast<float>(value(0)) != std::numeric_limits<float>::infinity(), value(0) ); assertion1( value(0) == value(0), value(0) ); // test for not a number assertion1( static_cast<float>(value(1)) != std::numeric_limits<float>::infinity(), value(1) ); assertion1( value(1) == value(1), value(1) ); // test for not a number while (_lastWriteCommandVertexNumber<index-1) { plotVertex(_lastWriteCommandVertexNumber+1,0.0); } _lastWriteCommandVertexNumber = index; _out << static_cast<float>(value(0)) << " "; _out << static_cast<float>(value(1)) << " "; for (int i=2; i<_recordsPerVertex; i++) { _out << 0.0 << " "; } _out << std::endl; if (value(0)<_minValue) _minValue = value(0); if (value(0)>_maxValue) _maxValue = value(0); if (value(1)<_minValue) _minValue = value(1); if (value(1)>_maxValue) _maxValue = value(1); }
void peano::applications::pic::demo2::mappings::RegularGrid2PlotSolution::handleCell( peano::applications::pic::demo2::RegularGridVertex* const vertices, peano::applications::pic::demo2::RegularGridCell& cell, const peano::kernel::gridinterface::VertexEnumerator& enumerator ) { logTraceInWith2Arguments( "handleCell()", enumerator.toString(), cell ); // @todo Insert your code here assertion( DIMENSIONS==2 || DIMENSIONS==3 ); int vertexIndex[TWO_POWER_D]; dfor2(i) tarch::la::Vector<DIMENSIONS,double> currentVertexPosition = enumerator.getVertexPosition(i); assertion1 ( _vertex2IndexMap.find(currentVertexPosition) != _vertex2IndexMap.end(), currentVertexPosition ); assertion1( _vertex2IndexMap[currentVertexPosition]>=0, _vertex2IndexMap[currentVertexPosition] ); vertexIndex[iScalar] = _vertex2IndexMap[currentVertexPosition]; enddforx int cellIndex; if (DIMENSIONS==2) { cellIndex = _cellWriter->plotQuadrangle(vertexIndex); } if (DIMENSIONS==3) { cellIndex = _cellWriter->plotHexahedron(vertexIndex); } _cellPWriter->plotCell( cellIndex,cell.getP() ); logTraceOut( "handleCell()" ); }
void UncoupledScheme:: initialize ( double startTime, int startTimestep ) { preciceTrace2 ( "initialize()", startTime, startTimestep ); setTime ( startTime ); setTimesteps ( startTimestep ); assertion1 ( tarch::la::greaterEquals(startTime, 0.0), startTime ); assertion1 ( startTimestep >= 0, startTimestep ); setIsInitialized(true); }
int peano::kernel::spacetreegrid::SingleLevelEnumerator::lineariseCellIndex( const LocalVertexIntegerIndex& cellPosition ) { int base = 1; int result = 0; for (int d=0; d<DIMENSIONS; d++) { assertion1(cellPosition(d)>=0,cellPosition); assertion1(cellPosition(d)<=2,cellPosition); result += cellPosition(d)*base; base *= 3; } assertion( result>= 0 ); assertion( result< THREE_POWER_D ); return result; }
int peano::kernel::spacetreegrid::SingleLevelEnumerator::lineariseVertexIndex( const LocalVertexIntegerIndex& vertexPosition ) { int base = 1; int result = 0; for (int d=0; d<DIMENSIONS; d++) { assertion1(vertexPosition(d)>=0,vertexPosition); assertion1(vertexPosition(d)<=3,vertexPosition); result += vertexPosition(d)*base; base *= 4; } assertion( result>= 0 ); assertion( result< FOUR_POWER_D ); return result; }
const utils::DynVector& delinearize ( int toDelinearize, int dimensions ) { if ( dimensions == 2 ){ assertion1 ( (toDelinearize >= 0) && (toDelinearize < 4), toDelinearize ); return DELINEARIZE_2D[toDelinearize]; } else { assertion1 ( dimensions == 3, dimensions ); assertion1 ( (toDelinearize >= 0) && (toDelinearize < 8), toDelinearize ); return DELINEARIZE_3D[toDelinearize]; } }
void peano::applications::pic::demo2::mappings::SpacetreeGrid2PlotSolution::enterCell( peano::applications::pic::demo2::SpacetreeGridCell& fineGridCell, peano::applications::pic::demo2::SpacetreeGridVertex * const fineGridVertices, const peano::kernel::gridinterface::VertexEnumerator& fineGridVerticesEnumerator, peano::applications::pic::demo2::SpacetreeGridVertex const * const coarseGridVertices, const peano::kernel::gridinterface::VertexEnumerator& coarseGridVerticesEnumerator, const peano::applications::pic::demo2::SpacetreeGridCell& coarseGridCell, const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfCell ) { logTraceInWith4Arguments( "enterCell(...)", fineGridCell, fineGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfCell ); if ( fineGridCell.isLeaf() ) { assertion( DIMENSIONS==2 || DIMENSIONS==3 ); int vertexIndex[TWO_POWER_D]; dfor2(i) tarch::la::Vector<DIMENSIONS,double> currentVertexPosition = fineGridVerticesEnumerator.getVertexPosition(i); assertion1 ( _vertex2IndexMap.find(currentVertexPosition) != _vertex2IndexMap.end(), currentVertexPosition ); vertexIndex[iScalar] = _vertex2IndexMap[currentVertexPosition]; enddforx int cellIndex; if (DIMENSIONS==2) { cellIndex = _cellWriter->plotQuadrangle(vertexIndex); } if (DIMENSIONS==3) { cellIndex = _cellWriter->plotHexahedron(vertexIndex); } _cellPWriter->plotCell( cellIndex,fineGridCell.getP() ); } logTraceOutWith1Argument( "enterCell(...)", fineGridCell ); }
double scenario::diffusionequation::CornerPointField::getPorosityFromDataSet(const tarch::la::Vector<3,double>& x) const { logTraceInWith3Arguments( "getPorosityFromDataSet(vector)", x, _hexahedron.getBoundingBox(), _hexahedron.getOffset() ); const double depth = x(2); const double pillarSizeX = getCornerPointPillarWidth()(0); assertion1( pillarSizeX>0.0, pillarSizeX ); int inArrayX = std::floor( (x(0)-_hexahedron.getOffset()(0)) / pillarSizeX ); if (inArrayX==_pillars(0)) inArrayX--; assertion3( inArrayX>=0, pillarSizeX, inArrayX, _pillars ); assertion3( inArrayX<_pillars(0), pillarSizeX, inArrayX, _pillars ); #if defined(Dim3) const double pillarSizeY = getCornerPointPillarWidth()(1); assertion4( pillarSizeY>0.0, pillarSizeX, pillarSizeY, inArrayX, _pillars ); int inArrayY = std::floor( (x(1)-_hexahedron.getOffset()(1)) / pillarSizeY ); if (inArrayY==_pillars(1)) inArrayY--; assertion5( inArrayY>=0, pillarSizeX, pillarSizeY, inArrayX, inArrayY, _pillars ); assertion5( inArrayY<_pillars(1), pillarSizeX, pillarSizeY, inArrayX, inArrayY, _pillars ); #elif defined(Dim2) const int inArrayY = _pillars(1) / 2; #endif const int entry = inArrayX + inArrayY * _pillars(0); assertion6( entry < static_cast<int>(_entries.size()), pillarSizeX, inArrayX, inArrayY, _pillars, entry, _entries.size() ); double result = _entries[entry].getPermeability(depth); logTraceOutWith1Argument( "getPorosityFromDataSet(vector)", result ); return result; }
void peano::applications::faxen::repositories::FaxenBatchJobRepositoryStatePacked::initDatatype() { const int Attributes = 2; MPI_Datatype subtypes[Attributes] = { MPI_INT, //action MPI_UB // end/displacement flag }; int blocklen[Attributes] = { 1, //action 1 // end/displacement flag }; MPI_Aint disp[Attributes]; FaxenBatchJobRepositoryStatePacked dummyFaxenBatchJobRepositoryStatePacked[2]; MPI_Aint base; MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyFaxenBatchJobRepositoryStatePacked[0]))), &base); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyFaxenBatchJobRepositoryStatePacked[0]._persistentRecords._action))), &disp[0] ); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyFaxenBatchJobRepositoryStatePacked[1]._persistentRecords._action))), &disp[1] ); for (int i=1; i<Attributes; i++) { assertion1( disp[i] > disp[i-1], i ); } for (int i=0; i<Attributes; i++) { disp[i] -= base; } MPI_Type_struct( Attributes, blocklen, disp, subtypes, &FaxenBatchJobRepositoryStatePacked::Datatype ); MPI_Type_commit( &FaxenBatchJobRepositoryStatePacked::Datatype ); }
void peano::integration::partitioncoupling::builtin::records::ForceTorquePacked::initDatatype() { const int Attributes = 3; MPI_Datatype subtypes[Attributes] = { MPI_DOUBLE, //_translationalForce MPI_DOUBLE, //_torque MPI_UB // end/displacement flag }; int blocklen[Attributes] = { 3, //_translationalForce 3, //_torque 1 // end/displacement flag }; MPI_Aint disp[Attributes]; ForceTorquePacked dummyForceTorquePacked[2]; MPI_Aint base; MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyForceTorquePacked[0]))), &base); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyForceTorquePacked[0]._persistentRecords._translationalForce[0]))), &disp[0] ); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyForceTorquePacked[0]._persistentRecords._torque[0]))), &disp[1] ); MPI_Address( const_cast<void*>(static_cast<const void*>(&dummyForceTorquePacked[1]._persistentRecords._translationalForce[0])), &disp[2] ); for (int i=1; i<Attributes; i++) { assertion1( disp[i] > disp[i-1], i ); } for (int i=0; i<Attributes; i++) { disp[i] -= base; } MPI_Type_struct( Attributes, blocklen, disp, subtypes, &ForceTorquePacked::Datatype ); MPI_Type_commit( &ForceTorquePacked::Datatype ); }
void peano::applications::latticeboltzmann::blocklatticeboltzmann::repositories::BlockLatticeBoltzmannBatchJobRepositoryState::initDatatype() { const int Attributes = 3; MPI_Datatype subtypes[Attributes] = { MPI_INT, //action MPI_CHAR, //reduceState MPI_UB // end/displacement flag }; int blocklen[Attributes] = { 1, //action 1, //reduceState 1 // end/displacement flag }; MPI_Aint disp[Attributes]; BlockLatticeBoltzmannBatchJobRepositoryState dummyBlockLatticeBoltzmannBatchJobRepositoryState[2]; MPI_Aint base; MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyBlockLatticeBoltzmannBatchJobRepositoryState[0]))), &base); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyBlockLatticeBoltzmannBatchJobRepositoryState[0]._persistentRecords._action))), &disp[0] ); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyBlockLatticeBoltzmannBatchJobRepositoryState[0]._persistentRecords._reduceState))), &disp[1] ); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyBlockLatticeBoltzmannBatchJobRepositoryState[1]._persistentRecords._action))), &disp[2] ); for (int i=1; i<Attributes; i++) { assertion1( disp[i] > disp[i-1], i ); } for (int i=0; i<Attributes; i++) { disp[i] -= base; } MPI_Type_struct( Attributes, blocklen, disp, subtypes, &BlockLatticeBoltzmannBatchJobRepositoryState::Datatype ); MPI_Type_commit( &BlockLatticeBoltzmannBatchJobRepositoryState::Datatype ); }
void Structure0815:: timestep(double dt) { STRUCTURE_DEBUG("Adding value changes to values."); _oldVelocities = _velocities; _oldDisplacements = _displacements; _time += dt; _timesteps++; DynVector centerOfGravity(_dim, 0.0); double totalMass = 0.0; double totalVolume = 0.0; if (not _fixedCharacteristics){ computeCharacteristics(centerOfGravity, totalMass, totalVolume); STRUCTURE_INFO("Center of gravity delta: " << _centerOfGravity - centerOfGravity); STRUCTURE_INFO("Total mass delta: " << _totalMass - totalMass); STRUCTURE_INFO("Total volume delta: " << _totalMass/_density - totalVolume); } _statisticsWriter.writeData(TIMESTEPS, _timesteps); _statisticsWriter.writeData(TIME, _time); if (_dim == 2){ precice::utils::Vector2D centerOfGravity2D(centerOfGravity); _statisticsWriter.writeData(CENTEROFGRAVITY, centerOfGravity2D); } else { assertion1(_dim == 3, _dim); precice::utils::Vector3D centerOfGravity3D(centerOfGravity); _statisticsWriter.writeData(CENTEROFGRAVITY, centerOfGravity3D); } _statisticsWriter.writeData(TOTALMASS, totalMass); _statisticsWriter.writeData(TOTALVOLUME, totalVolume); }
void NearestNeighborMapping:: computeMapping() { preciceTrace1("computeMapping()", input()->vertices().size()); assertion(input().get() != NULL); assertion(output().get() != NULL); if (getConstraint() == CONSISTENT){ preciceDebug("Compute consistent mapping"); size_t verticesSize = output()->vertices().size(); _vertexIndices.resize(verticesSize); const mesh::Mesh::VertexContainer& outputVertices = output()->vertices(); for ( size_t i=0; i < verticesSize; i++ ){ const utils::DynVector& coords = outputVertices[i].getCoords(); query::FindClosestVertex find(coords); find(*input()); assertion(find.hasFound()); _vertexIndices[i] = find.getClosestVertex().getID(); } } else { assertion1(getConstraint() == CONSERVATIVE, getConstraint()); preciceDebug("Compute conservative mapping"); size_t verticesSize = input()->vertices().size(); _vertexIndices.resize(verticesSize); const mesh::Mesh::VertexContainer& inputVertices = input()->vertices(); for ( size_t i=0; i < verticesSize; i++ ){ const utils::DynVector& coords = inputVertices[i].getCoords(); query::FindClosestVertex find(coords); find(*output()); assertion(find.hasFound()); _vertexIndices[i] = find.getClosestVertex().getID(); } } _hasComputedMapping = true; }
void peano::kernel::regulargrid::tests::records::TestCell::initDatatype() { const int Attributes = 1; MPI_Datatype subtypes[Attributes] = { MPI_UB // end/displacement flag }; int blocklen[Attributes] = { 1 // end/displacement flag }; MPI_Aint disp[Attributes]; TestCell dummyTestCell[2]; MPI_Aint base; MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyTestCell[0]))), &base); for (int i=1; i<Attributes; i++) { assertion1( disp[i] > disp[i-1], i ); } for (int i=0; i<Attributes; i++) { disp[i] -= base; } MPI_Type_struct( Attributes, blocklen, disp, subtypes, &TestCell::Datatype ); MPI_Type_commit( &TestCell::Datatype ); }
void peano::applications::latticeboltzmann::blocklatticeboltzmann::forcerecords::BlockPositionPacked::initDatatype() { const int Attributes = 2; MPI_Datatype subtypes[Attributes] = { MPI_DOUBLE, //_blockPosition MPI_UB // end/displacement flag }; int blocklen[Attributes] = { DIMENSIONS, //_blockPosition 1 // end/displacement flag }; MPI_Aint disp[Attributes]; BlockPositionPacked dummyBlockPositionPacked[2]; MPI_Aint base; MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyBlockPositionPacked[0]))), &base); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyBlockPositionPacked[0]._persistentRecords._blockPosition[0]))), &disp[0] ); MPI_Address( const_cast<void*>(static_cast<const void*>(&dummyBlockPositionPacked[1]._persistentRecords._blockPosition[0])), &disp[1] ); for (int i=1; i<Attributes; i++) { assertion1( disp[i] > disp[i-1], i ); } for (int i=0; i<Attributes; i++) { disp[i] -= base; } MPI_Type_struct( Attributes, blocklen, disp, subtypes, &BlockPositionPacked::Datatype ); MPI_Type_commit( &BlockPositionPacked::Datatype ); }
void tarch::parallel::messages::RegisterAtNodePoolMessagePacked::initDatatype() { const int Attributes = 2; MPI_Datatype subtypes[Attributes] = { MPI_SHORT, //nodeName MPI_UB // end/displacement flag }; int blocklen[Attributes] = { MPI_MAX_NAME_STRING_ADDED_ONE, //nodeName 1 // end/displacement flag }; MPI_Aint disp[Attributes]; RegisterAtNodePoolMessagePacked dummyRegisterAtNodePoolMessagePacked[2]; MPI_Aint base; MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyRegisterAtNodePoolMessagePacked[0]))), &base); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyRegisterAtNodePoolMessagePacked[0]._persistentRecords._nodeName[0]))), &disp[0] ); MPI_Address( const_cast<void*>(static_cast<const void*>(&dummyRegisterAtNodePoolMessagePacked[1]._persistentRecords._nodeName[0])), &disp[1] ); for (int i=1; i<Attributes; i++) { assertion1( disp[i] > disp[i-1], i ); } for (int i=0; i<Attributes; i++) { disp[i] -= base; } MPI_Type_struct( Attributes, blocklen, disp, subtypes, &RegisterAtNodePoolMessagePacked::Datatype ); MPI_Type_commit( &RegisterAtNodePoolMessagePacked::Datatype ); }
void peano::applications::poisson::jacobitutorial::mappings::RegularGrid2PlotSolution::handleCell( peano::applications::poisson::jacobitutorial::RegularGridVertex* const vertices, peano::applications::poisson::jacobitutorial::RegularGridCell& cell, const peano::kernel::gridinterface::VertexEnumerator& enumerator ) { logTraceInWith2Arguments( "handleCell()", enumerator.toString(), cell ); /** * --- inserted manually --- * * This is just cell plot mechanics. As the cells have no properties, it is * exactly the same what the grid plotter which is generated does. */ tarch::multicore::Lock localLock( _outputStreamSemaphore ); assertion( DIMENSIONS==2 || DIMENSIONS==3 ); int vertexIndex[TWO_POWER_D]; dfor2(i) tarch::la::Vector<DIMENSIONS,double> currentVertexPosition = enumerator.getVertexPosition(i); assertion1 ( _vertex2IndexMap.find(currentVertexPosition) != _vertex2IndexMap.end(), currentVertexPosition ); vertexIndex[iScalar] = _vertex2IndexMap[currentVertexPosition]; enddforx if (DIMENSIONS==2) { _cellWriter->plotQuadrangle(vertexIndex); } if (DIMENSIONS==3) { _cellWriter->plotHexahedron(vertexIndex); } logTraceOut( "handleCell()" ); }
tarch::logging::CommandLineLogger::FilterListEntry::FilterListEntry( const std::string& targetName, int rank, const std::string& className, bool isBlackListEntry ): _targetName(targetName), _rank(rank), _namespaceName(className), _isBlackEntry(isBlackListEntry) { assertion1( targetName==std::string("info") || targetName==std::string("debug") || targetName==std::string(""), targetName ); }
void peano::applications::navierstokes::prototype1::repositories::PrototypeRepositoryStatePacked::initDatatype() { const int Attributes = 3; MPI_Datatype subtypes[Attributes] = { MPI_INT, //action MPI_CHAR, //reduceState MPI_UB // end/displacement flag }; int blocklen[Attributes] = { 1, //action 1, //reduceState 1 // end/displacement flag }; MPI_Aint disp[Attributes]; PrototypeRepositoryStatePacked dummyPrototypeRepositoryStatePacked[2]; MPI_Aint base; MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyPrototypeRepositoryStatePacked[0]))), &base); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyPrototypeRepositoryStatePacked[0]._persistentRecords._action))), &disp[0] ); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyPrototypeRepositoryStatePacked[0]._persistentRecords._reduceState))), &disp[1] ); MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyPrototypeRepositoryStatePacked[1]._persistentRecords._action))), &disp[2] ); for (int i=1; i<Attributes; i++) { assertion1( disp[i] > disp[i-1], i ); } for (int i=0; i<Attributes; i++) { disp[i] -= base; } MPI_Type_struct( Attributes, blocklen, disp, subtypes, &PrototypeRepositoryStatePacked::Datatype ); MPI_Type_commit( &PrototypeRepositoryStatePacked::Datatype ); }
void peano::applications::poisson::jacobitutorial::records::RegularGridCell::initDatatype() { const int Attributes = 1; MPI_Datatype subtypes[Attributes] = { MPI_UB // end/displacement flag }; int blocklen[Attributes] = { 1 // end/displacement flag }; MPI_Aint disp[Attributes]; RegularGridCell dummyRegularGridCell[2]; MPI_Aint base; MPI_Address( const_cast<void*>(static_cast<const void*>(&(dummyRegularGridCell[0]))), &base); for (int i=1; i<Attributes; i++) { assertion1( disp[i] > disp[i-1], i ); } for (int i=0; i<Attributes; i++) { disp[i] -= base; } MPI_Type_struct( Attributes, blocklen, disp, subtypes, &RegularGridCell::Datatype ); MPI_Type_commit( &RegularGridCell::Datatype ); }
double peanoclaw::grid::TimeIntervals::getTimeUOld() const { assertion1(Patch::isLeaf(_cellDescription) || Patch::isVirtual(_cellDescription), toString()); if (Patch::isLeaf(_cellDescription)) { return _cellDescription->getTime(); } else { return _cellDescription->getMinimalNeighborTime(); } }
void particles::pidt::mappings::MoveParticles::touchVertexFirstTime( particles::pidt::Vertex& fineGridVertex, const tarch::la::Vector<DIMENSIONS,double>& fineGridX, const tarch::la::Vector<DIMENSIONS,double>& fineGridH, particles::pidt::Vertex * const coarseGridVertices, const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator, particles::pidt::Cell& coarseGridCell, const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfVertex ) { logTraceInWith6Arguments( "touchVertexFirstTime(...)", fineGridVertex, fineGridX, fineGridH, coarseGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfVertex ); #ifdef Parallel if (fineGridVertex.isAdjacentToRemoteRank()) { fineGridVertex.particlesWereAddedToThisVertex(); } else { fineGridVertex.noParticlesWereAddedToThisVertex(); } #else fineGridVertex.noParticlesWereAddedToThisVertex(); #endif const int vertexIndex = fineGridVertex.getVertexIndex(); typedef std::vector<particles::pidt::records::Particle> ParticleContainer; ParticleContainer& sourceVertexParticles = ParticleHeap::getInstance().getData(vertexIndex); pfor(i,0,static_cast<int>(sourceVertexParticles.size()),100) particles::pidt::records::Particle& currentParticle = sourceVertexParticles.at(i); assertion( currentParticle.getMovedParticle() == particles::pidt::records::Particle::New || currentParticle.getMovedParticle() == particles::pidt::records::Particle::Moved ); assertion1( tarch::la::allGreaterEquals(currentParticle._persistentRecords._x,0.0), currentParticle.toString() ); assertion1( tarch::la::allSmallerEquals(currentParticle._persistentRecords._x,1.0), currentParticle.toString() ); currentParticle.setMovedParticle( particles::pidt::records::Particle::NotMovedYet ); endpfor logTraceOutWith1Argument( "touchVertexFirstTime(...)", fineGridVertex ); }
void ImportSTL:: doImport ( const std::string& name, mesh::Mesh& mesh ) { preciceTrace1("doImport()", name); assertion1(mesh.getDimensions() == 3, mesh.getDimensions()); // TODO }
const std::string& XMLTag:: getStringAttributeValue ( const std::string& name ) const { std::map<std::string,XMLAttribute<std::string> >::const_iterator iter; iter = _stringAttributes.find(name); assertion1 (iter != _stringAttributes.end(), name); return iter->second.getValue(); }
int tarch::plotter::griddata::unstructured::binaryvtu::BinaryVTUTextFileWriter::VertexWriter::plotVertex(const tarch::la::Vector<2,double>& position) { assertion1( _currentVertexNumber>=0, _currentVertexNumber ); tarch::la::Vector<3,double> p; p(0) = position(0); p(1) = position(1); p(2) = 0.0; return plotVertex(p); }
double peano::applications::diffusionequation::Solver::getNewTemperatureForExplicitEulerStep( const tarch::la::Vector<DIMENSIONS,double>& h, double residual, const double & oldTemperature ) { const double cellVolume = tarch::la::volume(h); assertion1( _timeStepSize>0.0, _timeStepSize ); assertion1( cellVolume>0.0, cellVolume ); residual *= _timeStepSize / cellVolume; const double diagonalValue = 1.0; assertion1( _smoother.getOmega(), 1.0 ); tarch::multicore::Lock localLock(_normSemaphore); return _smoother.getNewValueOfJacobiStep(oldTemperature,residual,diagonalValue,cellVolume); }
int peanoclaw::Area::linearizeManifoldPosition( const tarch::la::Vector<DIMENSIONS, int>& manifoldPosition ) { assertion1(tarch::la::allSmaller(manifoldPosition, 2), manifoldPosition); int entry = peano::utils::dLinearised(manifoldPosition + 1, 3); if(entry > THREE_POWER_D_MINUS_ONE/2) { entry--; } return entry; }
void peano::geometry::builtin::configurations::BuiltinGeometryObjectConfiguration::readGeometryID( tarch::irr::io::IrrXMLReader* xmlReader){ // if available, parse geometry ID if (xmlReader->getAttributeValue(GEOMETRY_ID.c_str()) != 0){ _geometryID = xmlReader->getAttributeValueAsInt(GEOMETRY_ID.c_str()); if (_geometryID < 0){ assertion1(false, "Read negative geometry ID!"); exit(EXIT_FAILURE); } logDebug("readGeometryID()", "Geometry ID: " << _geometryID); } }
double peano::applications::diffusionequation::Solver::getNewTemperatureForImplicitEulerStep( const tarch::la::Vector<DIMENSIONS,double>& h, double residual, const peano::toolbox::stencil::Stencil& stencil, const double & newTemperatureSoFar ) { assertion1( _timeStepSize>0.0, _timeStepSize ); assertion1( tarch::la::volume(h)>0.0, h ); double diagonalElement = tarch::la::volume(h) * _elementMatrix.getDiagonalElement(_massMatrixWithoutHScaling) + _timeStepSize * _elementMatrix.getDiagonalElement(stencil); assertion( diagonalElement>0.0 ); tarch::multicore::Lock localLock(_normSemaphore); return _smoother.getNewValueOfJacobiStep( newTemperatureSoFar, residual, diagonalElement, tarch::la::volume(h) ); }