void GameObject::UpdateLocation(double time)
{
x_ += displacement(v_x_, a_x_, time);
y_ += displacement(v_y_, a_y_, time);
v_x_ += time * a_x_;
v_y_ += time * a_y_;
}
void BranchData::print_data_on(outputStream* st) {
print_shared(st, "BranchData");
st->print_cr("taken(%u) displacement(%d)",
taken(), displacement());
tab(st);
st->print_cr("not taken(%u)", not_taken());
}
//////////////////////
// The next three functions were cribbed from various ViewInteractor instances
//
void GeometryInteractor::doTranslation(SimpleOpenGLWidget* simpleOpenGLWidget,
int startX, int startY, int endX, int endY)
{
Quaternion orientation = simpleOpenGLWidget->getView().getOrientation();
Vector target = simpleOpenGLWidget->getView().getTarget();
float windowSize = simpleOpenGLWidget->getView().GetWindowSize();
int width = simpleOpenGLWidget->getWidth();
int height = simpleOpenGLWidget->getHeight();
float dx = (float)(endX-startX);
float dy = (float)(endY-startY);
Vector up(orientation.applyRotation(Vector(0.0f, 1.0f, 0.0f, 0.0f)));
Vector right(orientation.applyRotation(Vector(1.0f, 0.0f, 0.0f, 0.0f)));
float objectDx = dx * windowSize / (height<width?height: width);
float objectDy = dy * windowSize / (height<width?height: width);
Vector displacement(right*objectDx+up*objectDy);
//target-=displacement;
// update the target on the view
//simpleOpenGLWidget->getView().setTarget(target);
m_Geometry->translateBy(displacement[0]*10.0,
displacement[1]*10.0,
displacement[2]*10.0);
}
void Character::Update(float deltaTime)
{
const float kSpeed = 500.0f;
SVector2 displacement(0.0f, 0.0f);
// Check horizontal movement
if(Input_IsKeyDown(Keys::RIGHT))
{
displacement.x = kSpeed * deltaTime;
}
else if(Input_IsKeyDown(Keys::LEFT))
{
displacement.x = -kSpeed * deltaTime;
}
else
{
displacement.x = 0.0f;
}
// Check vertical movement
if(Input_IsKeyDown(Keys::DOWN))
{
displacement.y = kSpeed * deltaTime;
}
else if(Input_IsKeyDown(Keys::UP))
{
displacement.y = -kSpeed * deltaTime;
}
else
{
displacement.y = 0.0f;
}
mPosition += displacement;
}
/// output of the nonlinear function, the output is normalized with maximum value of 1
double run(double x)
{
double x1 = displacement(x);
double x2 = boltzman(x1);
//double x2 = (x1>0)?x1:0; //this is just a test
return(x2);
};
sf::Vector2f sbe::Wander::use(Unit& unit)
{
std::random_device rd;
std::mt19937_64 gen(rd());
std::uniform_real_distribution<float> disDouble;
sf::Vector2f circleCenter = sbe::AdvMath::normalize(unit.getVelocity());
circleCenter = sbe::AdvMath::multiply(circleCenter, circleDistance);
sf::Vector2f displacement(cos(wanderAngle), sin(wanderAngle));
displacement = sbe::AdvMath::multiply(displacement, circleRadius);
wanderAngle += (disDouble(gen) * angleChange) - angleChange / 2;
sf::Vector2f wanderForce = circleCenter + displacement;
this->wanderForce = wanderForce;
wanderForce = sbe::AdvMath::multiply(wanderForce, 1.0f / unit.getMass());
sf::Vector2f newVelocity = unit.getVelocity() + wanderForce;
if (sbe::AdvMath::magnitude(newVelocity) > unit.getMaxVelocity())
{
newVelocity = sbe::AdvMath::normalize(newVelocity);
newVelocity = sbe::AdvMath::multiply(newVelocity, unit.getMaxVelocity());
}
return newVelocity;
}
void FPSCameraTemplate::UpdatePosition(const SceneObject* scene_object, CameraPtr cam, Vector3f new_position)
{
Vector3f displacement(new_position - scene_object->getPosition());
Vector3f target(cam->getTarget());
target = target + displacement;
cam->setTarget(target);
}
main() {
struct tms buffer;
float t1,t2,ut,st;
t1 = clock();
times(&buffer);
ut = buffer.tms_utime;
st = buffer.tms_stime;
read_control_data();
read_node_data();
read_element_data();
gen_fem_model_data();
read_material_data();
read_load_data();
pre_assemble();
assemble_stiffness();
assemble_loadvec();
displacement();
forces();
t2 = clock();
times(&buffer);
printf("User time = %f System time = %f ",
(buffer.tms_utime-ut) / 60.0, (buffer.tms_stime -st) / 60.0);
printf("Real = %f \n", (t2-t1)/1.0e6);
}
QPoint neighbourPos(const QPoint& pos, core::Direction dir, int tileSize)
{
QSize displacement(0, 0);
switch (dir)
{
case core::Direction::West:
displacement.setWidth(-tileSize);
break;
case core::Direction::NorthWest:
displacement.setWidth(-tileSize / 2);
displacement.setHeight(-tileSize * 3 / 4);
break;
case core::Direction::NorthEast:
displacement.setWidth(tileSize / 2);
displacement.setHeight(-tileSize * 3 / 4);
break;
case core::Direction::East:
displacement.setWidth(tileSize);
break;
case core::Direction::SouthEast:
displacement.setWidth(tileSize / 2);
displacement.setHeight(tileSize * 3 / 4);
break;
case core::Direction::SouthWest:
displacement.setWidth(-tileSize / 2);
displacement.setHeight(tileSize * 3 / 4);
break;
}
return QPoint(pos.x() + displacement.width(), pos.y() + displacement.height());
}
void CurrentCoords<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
for (int cell=0; cell < workset.numCells; ++cell)
for (int node=0; node < numNodes; ++node)
for (int dim=0; dim < numDims; ++dim)
currentCoords(cell,node,dim) = refCoords(cell,node,dim) + displacement(cell,node,dim);
}
/*! \fn create_six_quads_patch_inverted_with_domain(PatchData &four_quads, MsqError &err)
our 2D set up: 6 quads, 1 center vertex outcentered by (0,-0.5), the other centered
7____6____5___11
| | | |
| 2 | 3 | 5 |
8 | 4---10 vertex 1 is at (0,0)
|\ /| | vertex 11 is at (3,2)
| | | 4 |
1----2----3----9
\ /
0
use destroy_patch_with_domain() in sync.
*/
inline void create_six_quads_patch_inverted_with_domain(PatchData &pd, MsqError &err)
{
create_six_quads_patch_with_domain(pd,err); MSQ_CHKERR(err);
Vector3D displacement(0,-1.5,0);
pd.move_vertex( displacement, 0, err );
}
address NativeCall::destination() const {
// Getting the destination of a call isn't safe because that call can
// be getting patched while you're calling this. There's only special
// places where this can be called but not automatically verifiable by
// checking which locks are held. The solution is true atomic patching
// on x86, nyi.
return return_address() + displacement();
}
std::vector<int> calculateDisplacement<int>(int dimCount, int unitDimension, double scale, const std::vector<double>& anglesInRadians) {
Point<double> res = calculateDisplacement<double>( dimCount, unitDimension, scale, anglesInRadians);
std::vector<int> displacement(dimCount, 0);
std::vector<double> coords = res.coords();
for (size_t i = 0; i < coords.size(); ++i) {
displacement[i] = rint(coords[i]);
}
return displacement;
}
void Test3DMeshTranslationWithUblasMethod()
{
TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/cube_136_elements");
TetrahedralMesh<3,3> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
// Translations - add a constant vector to each node
c_vector<double,3> displacement;
displacement(0) = 1;
displacement(1) = 1;
displacement(2) = 1;
// Translate the mesh along the vector displacement
mesh.Translate(displacement);
TetrahedralMesh<3,3> original_mesh;
original_mesh.ConstructFromMeshReader(mesh_reader);
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
// Find new coordinates of the translated node
Node<3>* p_node = mesh.GetNode(i);
ChastePoint<3> new_coordinate = p_node->GetPoint();
// Get original node
Node<3>* p_original_node = original_mesh.GetNode(i);
ChastePoint<3> original_coordinate = p_original_node->GetPoint();
// Run a test to make sure the node has gone to the correct place
TS_ASSERT_DELTA(original_coordinate[0] + displacement[0], new_coordinate[0], 1e-5);
TS_ASSERT_DELTA(original_coordinate[1] + displacement[1], new_coordinate[1], 1e-5);
TS_ASSERT_DELTA(original_coordinate[2] + displacement[2], new_coordinate[2], 1e-5);
}
// Check volume conservation
double mesh_volume = mesh.GetVolume();
double original_mesh_volume = original_mesh.GetVolume();
TS_ASSERT_DELTA(mesh_volume, original_mesh_volume, 1e-5);
}
void Instruction_baseRelative::execute() const
{
if (operation())
{
operation()->execute_baseRelative(reg(), baseRegister(), displacement());
}
else
{
std::cout << "No operation defined " << opcode_str()<< std::endl;
}
}
void Instruction_counterRelative::execute() const
{
if (operation())
{
operation()->execute_counterRelative(displacement());
}
else
{
std::cout << "No operation defined " << opcode_str() << std::endl;
}
}
/**
* \ingroup Communication
* Move the Object on Z,Y axis synchronously
*
* \param delta Object displacement
* \param speed Object speed
**/
void moveObject(const Eigen::Vector3d &delta, int speed)
{
if ( delta.norm() > 1e20 )
{ std::cerr << "Impossible position to reach! Check marker visibility!" << endl;
return;
}
Eigen::Vector3d displacement(0,-delta.y(),delta.z());
cerr << "Object moves " << -delta.y() << " vertically." << endl;
cerr << "Object moves " << delta.z() << " in depth." << endl;
}
void Warrior::handleOrders(Game* game){
InGameState *manager = (InGameState*)game->getGSM()->getManager();
if(order.type==MOVEORDER){
determineWayPoint(manager,game,order.x,order.y);
float dx = order.x-getWorldX();
float dy = order.y-getWorldY();
b2Vec2 displacement(dx,dy);
if(displacement.Length()<warriorFindTargetRange/2*BOX2D_Scale_Factor)
this->issueStopOrder();
}
else if(targetUnit==NULL && order.type==PATROLTOORDER){
determineWayPoint(manager,game,order.x,order.y);
float dx = (float)(order.x-getWorldX());
float dy = (float)(order.y-getWorldY());
b2Vec2 displacement(dx,dy);
if(displacement.Length()<warriorFindTargetRange/2*BOX2D_Scale_Factor){
int tmp = order.x;
order.x=order.initialX;
order.initialX=tmp;
tmp = order.y;
order.y=order.initialY;
order.initialY=tmp;
}
}
else if(order.type==ATTACKTOORDER && targetUnit==NULL){
determineWayPoint(manager,game,order.x,order.y);
float dx = order.x-getWorldX();
float dy = order.y-getWorldY();
b2Vec2 displacement(dx,dy);
if(displacement.Length()<warriorFindTargetRange/2*BOX2D_Scale_Factor)
this->issueStopOrder();
}
else if(order.type==ATTACKUNITORDER && targetUnit!=NULL)
determineWayPoint(manager,game,targetUnit->getWorldX(),targetUnit->getWorldY());
else if(targetUnit!=NULL && state==standby){
determineWayPoint(manager,game,targetUnit->getWorldX(),targetUnit->getWorldY());
}
else lastWaypointGeneration=10;
}
void ThirdPersonCamera::updateCameraPositionAndDirection()
{
float distanceOnX = distanceFromObject * sin(mAngleX);
float distanceOnZ = distanceFromObject * cos(mAngleX);
glm::vec3 displacement(distanceOnX, distanceOnY, distanceOnZ);
mPosition = mObjectPosition + displacement;
mDirection = mObjectPosition - mPosition;
mDirection = glm::normalize(mDirection);
}
void Player::update(int direction)
{
if (anim_clock.getElapsedTime() > sf::seconds(SPEED))
{
if (status == STOP)
{
return;
}
sprite.move(displacement(direction));
anim_clock.restart();
}
}
/*
BeginDocumentation
Name: topology::Displacement - compute displacement vector
Synopsis: from_gid to_gid Displacement -> [double vector]
from_pos to_gid Displacement -> [double vector]
Parameters:
from_gid - int, gid of node in a topology layer
from_pos - double vector, position in layer
to_gid - int, gid of node in a topology layer
Returns:
[double vector] - vector pointing from position "from" to position "to"
Description:
This function returns a vector connecting the position of the "from_gid"
node or the explicitly given "from_pos" position and the position of the
"to_gid" node. Nodes must be parts of topology layers.
The "from" position is projected into the layer of the "to_gid" node. If
this layer has periodic boundary conditions (EdgeWrap is true), then the
shortest displacement vector is returned, taking into account the
periodicity. Fixed grid layers are in this case extended so that the
nodes at the edges of the layer have a distance of one grid unit when
wrapped.
Example:
topology using
<< /rows 5
/columns 4
/elements /iaf_neuron
>> CreateLayer ;
4 5 Displacement
[0.2 0.3] 5 Displacement
Author: Håkon Enger, Hans E Plesser, Kittel Austvoll
See also: Distance, GetPosition
*/
void
TopologyModule::Displacement_a_iFunction::execute( SLIInterpreter* i ) const
{
i->assert_stack_load( 2 );
std::vector< double_t > point = getValue< std::vector< double_t > >( i->OStack.pick( 1 ) );
index node_gid = getValue< long_t >( i->OStack.pick( 0 ) );
Token result = displacement( point, node_gid );
i->OStack.pop( 2 );
i->OStack.push( result );
i->EStack.pop();
}
TEST(PointTest, TranslateMovesWithPointInput)
{
Point p;
Point displacement(2, 2);
Point expected(2, 2);
p.TranslateBy(displacement);
EXPECT_EQ(expected, p);
expected = Point(4, 4);
p.TranslateBy(displacement);
EXPECT_EQ(expected, p);
displacement = Point(-6, -10);
expected = Point(-2, -6);
p.TranslateBy(displacement);
EXPECT_EQ(expected, p);
}
KOKKOS_INLINE_FUNCTION
void operator()(int inode) const {
// Getting count as per 'CSR-like' data structure
const int element_offset = node_elem_offset(inode);
const int element_count = node_elem_offset(inode + 1) - element_offset ;
double local_force[] = {0.0, 0.0, 0.0};
// for each element that a node belongs to
for(int i = 0; i < element_count ; i++){
// node_elem_offset is a cumulative structure, so
// node_elem_offset(inode) should be the index where
// a particular row's elem_IDs begin
const int nelem = node_elem_ids( element_offset + i, 0);
// find the row in an element's stiffness matrix
// that corresponds to inode
const int elem_node_index = node_elem_ids( element_offset + i, 1);
local_force[0] += element_force(nelem, 0, elem_node_index);
local_force[1] += element_force(nelem, 1, elem_node_index);
local_force[2] += element_force(nelem, 2, elem_node_index);
}
internal_force(inode, 0) = local_force[0];
internal_force(inode, 1) = local_force[1];
internal_force(inode, 2) = local_force[2];
Scalar v_new[3];
Scalar a_current[3];
const Scalar tol = 1.0e-7;
if ( fabs(model_coords(inode,0)-x_bc) > tol ) { //not on x boundary
acceleration(inode,0) = a_current[0] = -local_force[0] / nodal_mass(inode);
acceleration(inode,1) = a_current[1] = -local_force[1] / nodal_mass(inode);
acceleration(inode,2) = a_current[2] = -local_force[2] / nodal_mass(inode);
} else { //enforce fixed BC
acceleration(inode,0) = a_current[0] = 0;
acceleration(inode,1) = a_current[1] = 0;
acceleration(inode,2) = a_current[2] = 0;
}
velocity(inode,0,next_state) = v_new[0] = velocity(inode,0,current_state) + (*prev_dt+*dt)/2.0*a_current[0];
velocity(inode,1,next_state) = v_new[1] = velocity(inode,1,current_state) + (*prev_dt+*dt)/2.0*a_current[1];
velocity(inode,2,next_state) = v_new[2] = velocity(inode,2,current_state) + (*prev_dt+*dt)/2.0*a_current[2];
displacement(inode,0,next_state) = displacement(inode,0,current_state) + *dt*v_new[0];
displacement(inode,1,next_state) = displacement(inode,1,current_state) + *dt*v_new[1];
displacement(inode,2,next_state) = displacement(inode,2,current_state) + *dt*v_new[2];
}
void displacementFunction(const struct RTCDisplacementFunctionNArguments* args)
{
const float* nx = args->Ng_x;
const float* ny = args->Ng_y;
const float* nz = args->Ng_z;
float* px = args->P_x;
float* py = args->P_y;
float* pz = args->P_z;
unsigned int N = args->N;
for (unsigned int i=0; i<N; i++) {
const Vec3fa P = Vec3fa(px[i],py[i],pz[i]);
const Vec3fa Ng = Vec3fa(nx[i],ny[i],nz[i]);
const Vec3fa dP = displacement(P)*Ng;
px[i] += dP.x; py[i] += dP.y; pz[i] += dP.z;
}
}
void displacementFunction(void* ptr, unsigned int geomID, int unsigned primID,
const float* u, /*!< u coordinates (source) */
const float* v, /*!< v coordinates (source) */
const float* nx, /*!< x coordinates of normal at point to displace (source) */
const float* ny, /*!< y coordinates of normal at point to displace (source) */
const float* nz, /*!< z coordinates of normal at point to displace (source) */
float* px, /*!< x coordinates of points to displace (source and target) */
float* py, /*!< y coordinates of points to displace (source and target) */
float* pz, /*!< z coordinates of points to displace (source and target) */
size_t N)
{
for (size_t i = 0; i<N; i++) {
const Vec3fa P = Vec3fa(px[i],py[i],pz[i]);
const Vec3fa Ng = Vec3fa(nx[i],ny[i],nz[i]);
const Vec3fa dP = displacement(P)*Ng;
px[i] += dP.x; py[i] += dP.y; pz[i] += dP.z;
}
}
TEST(MeshLib, moveMeshNodes)
{
/* initialize random seed: */
srand ( static_cast<unsigned>(time(NULL)) );
std::size_t const size (16384);
std::vector<MeshLib::Node*> nodes, nodes_copy;
nodes.resize(size);
nodes_copy.resize(size);
/* put nodes with random coords into vectors */
for (std::size_t k(0); k<size; k++) {
nodes[k] = new MeshLib::Node(rand(), rand(), rand());
nodes_copy[k] = new MeshLib::Node(* nodes[k]);
}
/* create random displacement */
MeshLib::Node displacement(rand(), rand(), rand());
/* move the mesh node */
MeshLib::moveMeshNodes(nodes.begin(), nodes.end(), displacement);
/* reverse the direction of displacement */
displacement[0] *= -1.0;
displacement[1] *= -1.0;
displacement[2] *= -1.0;
/* move the mesh node back */
MeshLib::moveMeshNodes(nodes.begin(), nodes.end(), displacement);
/* check the result */
double const eps(std::numeric_limits<double>::epsilon());
for (std::size_t k(0); k<size; k++) {
EXPECT_NEAR((*nodes_copy[0])[0], (*nodes[0])[0], eps);
EXPECT_NEAR((*nodes_copy[0])[1], (*nodes[0])[1], eps);
EXPECT_NEAR((*nodes_copy[0])[2], (*nodes[0])[2], eps);
}
for (auto n : nodes)
delete n;
for (auto n : nodes_copy)
delete n;
}
void MyWorker::synchronizeRenderer(Renderable *renderableObject)
{
TriangleCollection* triangleCollection = qobject_cast<TriangleCollection*>(renderableObject);
QVector3D displacement(140, 140, 75);
if(triangleCollection) {
//std::cout << "Synchronizing vertices" << std::endl;
triangleCollection->data.resize(vertices.size());
triangleCollection->dirty = true;
for(int i=0; i<vertices.size()/3; i++) {
QVector3D &p1 = vertices[3*i+0];
QVector3D &p2 = vertices[3*i+1];
QVector3D &p3 = vertices[3*i+2];
QVector3D normal = QVector3D::crossProduct((p1-p2), (p1-p3)).normalized();
QColor colorTmp;
//colorTmp.setRedF(intensities[i]);
//colorTmp.setGreenF(intensities[i]);
//colorTmp.setBlueF(intensities[i]);
//QVector3D color(colorTmp.redF(), colorTmp.greenF(), colorTmp.blueF());
QVector3D color(0.5, 0.5, 0.5);
for(int j=0; j<3; j++) {
triangleCollection->data[3*i+j].vertex = vertices[3*i+j]-displacement;
triangleCollection->data[3*i+j].color = color;
triangleCollection->data[3*i+j].normal = normal;
}
}
}
Spheres *qspheres = qobject_cast<Spheres*>(renderableObject);
if(qspheres) {
qspheres->positions().resize(spheres.size());
qspheres->colors().resize(spheres.size());
qspheres->scales().resize(spheres.size());
for(uint i=0; i<spheres.size(); i++) {
qspheres->positions()[i] = QVector3D(spheres[i].position.x(), spheres[i].position.y(), spheres[i].position.z())-displacement;
qspheres->colors()[i] = QColor("red");
qspheres->scales()[i] = 1.0;
}
qspheres->setDirty(true);
}
}
void CTriangleObj::glDrawElementLine(const int eid, const float offset, const bool needtex)
{
Vector3i*& m_pTriangle = (Vector3i*&)m_pPolygon;
Vector3d p0, p1, p2, *vt = m_pVertex;
Vector3d displacement(0,0,0);
Vector3i &quad = m_pTriangle[eid];
int v0=quad.x, v1=quad.y, v2=quad.z;
if (fabs(offset)>1E-12){
Vector3f &norm = m_pPolyNorm[eid];
displacement.x = offset*norm.x;
displacement.y = offset*norm.y;
displacement.z = offset*norm.z;
p0 = vt[v0] + displacement;
p1 = vt[v1] + displacement;
p2 = vt[v2] + displacement;
}
else{
p0 = vt[v0];
p1 = vt[v1];
p2 = vt[v2];
}
// if (v0<v1){
if (needtex && m_pVertexTexCoor1D) glTexCoord1f(m_pVertexTexCoor1D[v0]);
glVertex3dv(&p0.x);
if (needtex && m_pVertexTexCoor1D) glTexCoord1f(m_pVertexTexCoor1D[v1]);
glVertex3dv(&p1.x);
// }
// if (v1<v2){
if (needtex && m_pVertexTexCoor1D) glTexCoord1f(m_pVertexTexCoor1D[v1]);
glVertex3dv(&p1.x);
if (needtex && m_pVertexTexCoor1D) glTexCoord1f(m_pVertexTexCoor1D[v2]);
glVertex3dv(&p2.x);
// }
// if (v2<v0){
if (needtex && m_pVertexTexCoor1D) glTexCoord1f(m_pVertexTexCoor1D[v2]);
glVertex3dv(&p2.x);
if (needtex && m_pVertexTexCoor1D) glTexCoord1f(m_pVertexTexCoor1D[v0]);
glVertex3dv(&p0.x);
// }
}
boost::shared_ptr<SmileSection>
StrippedOptionletAdapter::smileSectionImpl(Time t) const {
std::vector< Rate > optionletStrikes =
optionletStripper_->optionletStrikes(
0); // strikes are the same for all times ?!
std::vector< Real > stddevs;
for (Size i = 0; i < optionletStrikes.size(); i++) {
stddevs.push_back(volatilityImpl(t, optionletStrikes[i]) *
std::sqrt(t));
}
// Extrapolation may be a problem with splines, but since minStrike()
// and maxStrike() are set, we assume that no one will use stddevs for
// strikes outside these strikes
CubicInterpolation::BoundaryCondition bc =
optionletStrikes.size() >= 4 ? CubicInterpolation::Lagrange
: CubicInterpolation::SecondDerivative;
return boost::make_shared< InterpolatedSmileSection< Cubic > >(
t, optionletStrikes, stddevs, Null< Real >(),
Cubic(CubicInterpolation::Spline, false, bc, 0.0, bc, 0.0),
Actual365Fixed(), volatilityType(), displacement());
}
void VtkNonlinearElasticitySolutionWriter<DIM>::Write()
{
if (mpSolver->mOutputDirectory=="")
{
EXCEPTION("No output directory was given to the mechanics solver");
}
#ifdef CHASTE_VTK
VtkMeshWriter<DIM, DIM> mesh_writer(mpSolver->mOutputDirectory + "/vtk", "solution", true);
// write the displacement
std::vector<c_vector<double,DIM> > displacement(mpSolver->mrQuadMesh.GetNumNodes());
std::vector<c_vector<double,DIM> >& r_spatial_solution = mpSolver->rGetSpatialSolution();
for(unsigned i=0; i<mpSolver->mrQuadMesh.GetNumNodes(); i++)
{
for(unsigned j=0; j<DIM; j++)
{
displacement[i](j) = r_spatial_solution[i](j)- mpSolver->mrQuadMesh.GetNode(i)->rGetLocation()[j];
}
}
mesh_writer.AddPointData("Displacement", displacement);
// write pressures
if (mpSolver->mCompressibilityType==INCOMPRESSIBLE)
{
mesh_writer.AddPointData("Pressure", mpSolver->rGetPressures());
}
// write the element attribute as cell data.
std::vector<double> element_attribute;
for(typename QuadraticMesh<DIM>::ElementIterator iter = mpSolver->mrQuadMesh.GetElementIteratorBegin();
iter != mpSolver->mrQuadMesh.GetElementIteratorEnd();
++iter)
{
element_attribute.push_back(iter->GetAttribute());
}
mesh_writer.AddCellData("Attribute", element_attribute);
// write strains if requested
if (mWriteElementWiseStrains)
{
mTensorData.clear();
mTensorData.resize(mpSolver->mrQuadMesh.GetNumElements());
std::string name;
switch(mElementWiseStrainType)
{
case DEFORMATION_GRADIENT_F:
{
name = "deformation_gradient_F";
break;
}
case DEFORMATION_TENSOR_C:
{
name = "deformation_tensor_C";
break;
}
case LAGRANGE_STRAIN_E:
{
name = "Lagrange_strain_E";
break;
}
default:
{
NEVER_REACHED;
}
}
for (typename AbstractTetrahedralMesh<DIM,DIM>::ElementIterator iter = mpSolver->mrQuadMesh.GetElementIteratorBegin();
iter != mpSolver->mrQuadMesh.GetElementIteratorEnd();
++iter)
{
mpSolver->GetElementCentroidStrain(mElementWiseStrainType, *iter, mTensorData[iter->GetIndex()]);
}
mesh_writer.AddTensorCellData(name, mTensorData);
}
//// Future..
// if (mWriteNodeWiseStresses)
// {
// std::vector<c_matrix<double,DIM,DIM> > tensor_data;
// // use recoverer
// mesh_writer.AddTensorCellData("Stress_NAME_ME", tensor_data);
// }
// final write
mesh_writer.WriteFilesUsingMesh(mpSolver->mrQuadMesh);
#endif // CHASTE_VTK
}
