/**
   * aligns the body x axis with the velocity vector
   */
  void alignVelocityXAxis(double vel_tol = .01)
  {
    Eigen::Quaterniond wind_axes_to_body_axes = Eigen::Quaterniond::Identity(); //transforms vectors in wind frame to vectors in body frame
    if (velocity().norm() > vel_tol) {
      wind_axes_to_body_axes.setFromTwoVectors(Eigen::Vector3d::UnitX(), velocity());
    }

    Eigen::Matrix3d body_axes_to_wind_axes = wind_axes_to_body_axes.toRotationMatrix().transpose();

    angularVelocity() = body_axes_to_wind_axes * angularVelocity();
    velocity() = body_axes_to_wind_axes * velocity();
    acceleration() = body_axes_to_wind_axes * acceleration();
    orientation() = orientation() * wind_axes_to_body_axes;
  }
Exemple #2
0
	/* Complete this function */
	void init(const Vector3 & spawnPoint)
	{
	  // Vectors used to create new particle
	  Vector3 velocity( 0, 5, 0);
	  Vector3 acceleration( 0, 0, 0);
	  Color3d colors( 0, 0, 1);
	  
	  for(int i = 0; i < 1500; ++i)
	    {
	      // Get angle for velocity
	      float theta = randFloat();
	      
	      // Get random velocity
	      velocity = Vector3( randFloat(-50*cos(theta), 50 * sin(theta)),
				  randFloat(-50*cos(theta), 50 * sin(theta)),
				  randFloat(0,10) );

	      // Get random colors for each particle
	      colors = Color3d( randFloat(0,1), randFloat(0,.2), randFloat(0,1) );
      
	      // Determine acceleration in one direction
	      acceleration.y = -10;
	      
	      // Push back newly created particle in vector
	      particles.push_back( Particle( spawnPoint, velocity, acceleration, colors, 10.0) );	
	    }
		
	}
Exemple #3
0
//----------------------------------------------------------------------
// RK4 functions
// floating point ops: 6
//----------------------------------------------------------------------
Derivative evaluate(State initial, float t)
{
   Derivative OUT;
   OUT.dx = initial.v;
   OUT.dv = acceleration(initial, t);
   return OUT;
}
Exemple #4
0
void BulletEmitter::pattern3()
{
    if (timeRef > 0)
    {
        Vector2f position(320.0f, 240.0f);
        Vector2f acceleration(0.0f, 0.0f);
        Color color(0.8f, 0.0f, 1.0f, 0.9f);
        float magnitude = 4.0f;

        Bullet b;
        b.set(position, dir, magnitude, acceleration, color);
        bulletMem.add(b);
        b.set(position, dir + 3.14f, magnitude, acceleration, color);
        bulletMem.add(b);
        b.set(position, dir + 3.14f / 2, magnitude, acceleration, color);
        bulletMem.add(b);
        b.set(position, dir + 3 * 3.14f / 2, magnitude, acceleration, color);
        bulletMem.add(b);

        b.set(position, -dir, magnitude, acceleration, color);
        bulletMem.add(b);
        b.set(position, -dir + 3.14f, magnitude, acceleration, color);
        bulletMem.add(b);
        b.set(position, -dir + 3.14f / 2, magnitude, acceleration, color);
        bulletMem.add(b);
        b.set(position, -dir + 3 * 3.14f / 2, magnitude, acceleration, color);
        bulletMem.add(b);

        dir += 0.03f;
    }
    --timeRef;
    if (timeRef < -10)
        timeRef = 30;
}
Exemple #5
0
void BulletEmitter::pattern2()
{
    if (timeRef == 0)
    {
        Vector2f position(320.0f, 240.0f);
        Vector2f acceleration(0.0f, 0.0f);
        Color color(0.8f, 0.0f, 1.0f, 0.9f);

        for (int i = 0; i < 1; ++i)
        {
            float initialDir = rng.genRand(0.0, 6.28);
            float fireDir = rng.genRand(3.14 / 3, 2 * 3.14 / 3);
            float magnitude = rng.genRand(2.0, 4.0);

            for (int i = 0; i < 180; ++i)
            {
                Bullet b;
                b.set(position, initialDir, magnitude, acceleration, color);

                b.queueAction(BulletAction(&bulletMem, VelocityAbs,  20,  2));
                b.queueAction(BulletAction(&bulletMem, DirectionAbs, 20,  (float)i * 30 / 6.28));
                b.queueAction(BulletAction(&bulletMem, VelocityAbs,  40,  0.001));
                b.queueAction(BulletAction(&bulletMem, VelocityAbs,  100, 7));
                b.queueAction(BulletAction(&bulletMem, DirectionAbs, 100, fireDir));

                bulletMem.add(b);
            }
        }
        timeRef = 30;
    }
    else
        timeRef--;
}
Exemple #6
0
int main()
{
    //maakt buiten kant weg
    for( j = 0 ; j < 75 ; ++j ){
        for( i = 0; i < 75 ; ++i ){
            map[j][linksbuiten] = '|';
            map[j][rechtsbuiten] = '|';
        }
    }
    //maakt de binnen weg
    for(int i=0; i < 20; ++i) {
        for(int j=0; j < 20; ++j) {
            map[i][linksbinnen] = '#';
            map[i][rechtsbinnen] = '#';
        }
    }

    for( ; ; )
    {
        weggetje();
        clearscreen();
        //getch();
        acceleration();
        keyhit();
    }
}
void Physics::updateKinematics(float delta){
	Vector displacement=delta*velocity_+0.5f*delta*delta*acceleration_;
	bv_->translate(displacement.x,displacement.y,displacement.z);
	velocity_+=(delta*acceleration());

	Matrix omega(	0,		angVel_.z,	-angVel_.y, 0,
				-angVel_.z,		0,		angVel_.x, 0,
				angVel_.y,	-angVel_.x,		0,		0,
				0,0,0,0);                                         //set up the matrix for calculating rotation based on
	                                                        //the objects angular velocity

	Matrix Rcurr= bv_->rotation();								//Get the current rotation of the object

	Matrix Rdelta=delta*(omega*Rcurr);							//Calculate the change in rotation of the object

	Matrix Rnew=orthoNormalize(Rcurr+Rdelta);				//calculate the new rotation matrix

	Matrix Rnet=orthoNormalize(Rcurr.transpose()*Rnew);		//figure out what the net rotation is

	angVel_=angVel_+delta*angAccel_;							//update the angular velocity

	bv_->rotate(Rnet);


}
void MouseWrapper_::move( int8_t x, int8_t y) {

    if (x != 0 || y != 0) {
        mouseActiveForCycles++;
        double accel = (double) acceleration(mouseActiveForCycles);
        float moveX = 0;
        float moveY = 0;
        if (x > 0) {
            moveX = (x * accel) + carriedOverX;
            carriedOverX = moveX - floor(moveX);
        } else if (x < 0) {
            moveX = (x * accel) - carriedOverX;
            carriedOverX = ceil(moveX) - moveX;
        }

        if (y > 0) {
            moveY = (y * accel) + carriedOverY;
            carriedOverY = moveY - floor(moveY);
        } else if (y < 0) {
            moveY = (y * accel) - carriedOverY;
            carriedOverY = ceil(moveY) - moveY;
        }
        end_warping();

        Mouse.move(moveX, moveY, 0);
    } else {
        mouseActiveForCycles = 0;
    }

}
void StabilizeStepper::step() {
    const std::size_t num_beads(_space->num_beads());

    // Calculate Force
    vector_list acceleration(num_beads, Vector3d(0,0,0));
    const vector_list force_list(_model->calculate_force(*(_space.get())));
    double max_accel(0);
    for (std::size_t i(0); i < num_beads; ++i) {
        acceleration[i] = force_list.at(i) / _mass_list.at(i);
        if (norm(acceleration[i]) > max_accel)
            max_accel = norm(acceleration[i]);
    }

    // Calculate delta
    _dt = sqrt(_dx/max_accel)/2;

    // Update Coordinate
    std::list<double> displacements;
    for (std::size_t i(0); i < num_beads; ++i) {
        const Vector3d direction(acceleration.at(i) * _dt*_dt/2);
        _space->move(i, direction);
        displacements.push_back(norm(direction));
    }

    // Update NeighborList
    for (auto itr(_neighbor_list_managers.begin()); itr != _neighbor_list_managers.end(); ++itr) {
        (*itr).add_displacements(displacements);
        if ((*itr).to_update(_space->t()))
            (*itr).update(*(_space.get()));
    }

    _space->set_t(_space->t() + _dt);
}
Exemple #10
0
Derivative evaluate(const State &initial, float t)
{
	Derivative output;
	output.dx = initial.v;
	output.dv = acceleration(initial, t);
	return output;
}
void Foam::fv::tabulatedAccelerationSource::addSup
(
    const RhoFieldType& rho,
    fvMatrix<vector>& eqn,
    const label fieldi
)
{
    Vector<vector> acceleration(motion_.acceleration());

    // If gravitational force is present combine with the linear acceleration
    if (mesh_.foundObject<uniformDimensionedVectorField>("g"))
    {
        uniformDimensionedVectorField& g =
            mesh_.lookupObjectRef<uniformDimensionedVectorField>("g");

        const uniformDimensionedScalarField& hRef =
            mesh_.lookupObject<uniformDimensionedScalarField>("hRef");

        g = g0_ - dimensionedVector("a", dimAcceleration, acceleration.x());

        dimensionedScalar ghRef
        (
            mag(g.value()) > SMALL
          ? g & (cmptMag(g.value())/mag(g.value()))*hRef
          : dimensionedScalar("ghRef", g.dimensions()*dimLength, 0)
        );

        mesh_.lookupObjectRef<volScalarField>("gh") = (g & mesh_.C()) - ghRef;

        mesh_.lookupObjectRef<surfaceScalarField>("ghf") =
            (g & mesh_.Cf()) - ghRef;
    }
    // ... otherwise include explicitly in the momentum equation
    else
    {
        eqn -= rho*dimensionedVector("a", dimAcceleration, acceleration.x());
    }

    dimensionedVector Omega
    (
        "Omega",
        dimensionSet(0, 0, -1, 0, 0),
        acceleration.y()
    );

    dimensionedVector dOmegaDT
    (
        "dOmegaDT",
        dimensionSet(0, 0, -2, 0, 0),
        acceleration.z()
    );

    eqn -=
    (
        rho*(2*Omega ^ eqn.psi())         // Coriolis force
      + rho*(Omega ^ (Omega ^ mesh_.C())) // Centrifugal force
      + rho*(dOmegaDT ^ mesh_.C())        // Angular tabulatedAcceleration force
    );
}
Exemple #12
0
Derivative evaluate(const RigidBody *initial, float t)
{
    Derivative output;
    output.dx = initial->_velocity;
    output.dv = acceleration();
    output.w = initial->_angularVelocity;
    output.dw = 0;
    return output;
}
Exemple #13
0
Derivative evaluate(const State &initial, float t, float dt, const Derivative &d)
{
	State state;
	state.x = initial.x + d.dx*dt;
	state.v = initial.v + d.dv*dt;
	Derivative output;
	output.dx = state.v;
	output.dv = acceleration(state, t+dt);
	return output;
}
Exemple #14
0
int QDeclarativeParticleMotionGravity::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDeclarativeParticleMotion::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0:
            *reinterpret_cast< qreal*>(_v) = xAttractor();
            break;
        case 1:
            *reinterpret_cast< qreal*>(_v) = yAttractor();
            break;
        case 2:
            *reinterpret_cast< qreal*>(_v) = acceleration();
            break;
        }
        _id -= 3;
    } else if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0:
            setXAttractor(*reinterpret_cast< qreal*>(_v));
            break;
        case 1:
            setYAttractor(*reinterpret_cast< qreal*>(_v));
            break;
        case 2:
            setAcceleration(*reinterpret_cast< qreal*>(_v));
            break;
        }
        _id -= 3;
    } else if (_c == QMetaObject::ResetProperty) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 3;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
Exemple #15
0
void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* smgr,
		LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
{
	// Texture
	u8 texid = myrand_range(0, 5);
	video::ITexture *texture;
	struct TileAnimationParams anim;
	anim.type = TAT_NONE;

	// Only use first frame of animated texture
	if (tiles[texid].material_flags & MATERIAL_FLAG_ANIMATION)
		texture = tiles[texid].frames[0].texture;
	else
		texture = tiles[texid].texture;

	float size = rand() % 64 / 512.;
	float visual_size = BS * size;
	v2f texsize(size * 2, size * 2);
	v2f texpos;
	texpos.X = ((rand() % 64) / 64. - texsize.X);
	texpos.Y = ((rand() % 64) / 64. - texsize.Y);

	// Physics
	v3f velocity((rand() % 100 / 50. - 1) / 1.5,
			rand() % 100 / 35.,
			(rand() % 100 / 50. - 1) / 1.5);

	v3f acceleration(0,-9,0);
	v3f particlepos = v3f(
		(f32) pos.X + rand() %100 /200. - 0.25,
		(f32) pos.Y + rand() %100 /200. - 0.25,
		(f32) pos.Z + rand() %100 /200. - 0.25
	);

	Particle* toadd = new Particle(
		gamedef,
		smgr,
		player,
		m_env,
		particlepos,
		velocity,
		acceleration,
		rand() % 100 / 100., // expiration time
		visual_size,
		true,
		false,
		false,
		texture,
		texpos,
		texsize,
		anim,
		0);

	addParticle(toadd);
}
Exemple #16
0
//gets the closest object on the path of this ray
//and sets t to whatever the appropriate t value is
//will return a negative t if the object is behind us
SceneObject getClosestObject(Ray ray, float * t, SceneProperties scene) {

    if (useAccelStructure) {
        return acceleration(ray, t, scene);
    }
    
    else {
        return noAcceleration(ray, t, scene);
    }

}
void YHEntity::calculateWithRK4(YHVector2 & pos, YHVector2 & vel, YHVector2 & acc, float dt) const
{
	YHVector2 pos2 = YHVector2(pos.getX() + vel.getX() * 0.5f * dt, pos.getY() + vel.getY() * 0.5f * dt);
	YHVector2 vel2 = YHVector2(vel.getX() + acc.getX() * 0.5f * dt, vel.getY() + acc.getY() * 0.5f * dt);
	YHVector2 acc2 = acceleration(pos2, vel2, acc, dt);
	
	YHVector2 pos3 = YHVector2(pos.getX() + vel2.getX() * 0.5f * dt, pos.getY() + vel2.getY() * 0.5f * dt);
	YHVector2 vel3 = YHVector2(vel.getX() + acc2.getX() * 0.5f * dt, vel.getY() + acc2.getY() * 0.5f * dt);
	YHVector2 acc3 = acceleration(pos3, vel3, acc, dt);
	
	YHVector2 pos4 = YHVector2(pos.getX() + vel3.getX() * dt, pos.getY() + vel3.getY() * dt);
	YHVector2 vel4 = YHVector2(vel.getX() + acc3.getX() * dt, vel.getY() + acc3.getY() * dt);
	YHVector2 acc4 = acceleration(pos4, vel4, acc, dt);
	
	pos.setX(pos.getX() + (vel.getX() + 2.0f * vel2.getX() + 2.0f * vel3.getX() + vel4.getX()) / 6.0f * dt);
	pos.setY(pos.getY() + (vel.getY() + 2.0f * vel2.getY() + 2.0f * vel3.getY() + vel4.getY()) / 6.0f * dt);
	
	vel.setX(vel.getX() + (acc.getX() + 2.0f * acc2.getX() + 2.0f * acc3.getX() + acc4.getX()) / 6.0f * dt);
	vel.setY(vel.getY() + (acc.getY() + 2.0f * acc2.getY() + 2.0f * acc3.getY() + acc4.getY()) / 6.0f * dt);
}
Exemple #18
0
task main()
{
    acceleration(5);
    wait1Msec(1000);
    acceleration(15);
    wait1Msec(1000);
    turnaround(20, 'p');
    wait1Msec(1000);
    turnaround(10, 'u');
    wait1Msec(1000);
    turnaround(30, 't');
    wait1Msec(1000);
    square(10);
    wait1Msec(1000);
    square(25);
    wait1Msec(1000);
    circle(10);
    wait1Msec(1000);
    circle(20);

}
Configurations step(Parameters ps, Configurations cs, Length dx, Time dt)
{
    assert(ps.m.size()        == cs.position.size());
    assert(cs.position.size() == cs.velocity.size());
    Configurations csp = cs;
    for (unsigned i = 0; i < cs.position.size(); i++)
    {
        csp.position[i] = cs.position[i] + cs.velocity[i] * dt;
        csp.velocity[i] = cs.velocity[i] + acceleration(i, ps, cs, dx) * dt;
    }
    return csp;
}
Exemple #20
0
// floating point ops: 11
Derivative evaluate(State initial, float t, float dt, Derivative d)
{
   State state;
   state.x = initial.x + d.dx * dt;
   state.v = initial.v + d.dv * dt;
   
   Derivative OUT;
   OUT.dx = state.v;
   OUT.dv = acceleration(state, t+dt);
   
   return OUT;
}
Exemple #21
0
bool Entity::update(float deltaTime) {
  b2Vec2 velocity = _body->GetLinearVelocity();
  b2Vec2 force(0.0f, 0.0f), acceleration(0.0f, 0.0f);

  acceleration.x = _velocity.x - velocity.x;
  acceleration.y = _velocity.y - velocity.y;
  
  force = _body->GetMass() * acceleration;

  //_body->ApplyLinearImpulse(force, _body->GetWorldCenter(), true);
  _body->SetLinearVelocity(Utils::toB2Vec2(_velocity));

  return true;
}
Exemple #22
0
void GameObject::updatePosition(sf::Time elapsedTime)
{
    sf::Vector2f acceleration(resultantForce.x / mass, resultantForce.y / mass);

    //calculate velocity
    sf::Vector2f newVelocity = velocity + acceleration*elapsedTime.asSeconds();
    float newVelocityLen = ezo::vecLength(newVelocity.x, newVelocity.y);
    if(newVelocityLen > maxVelocity)
        velocity = {newVelocity.x/newVelocityLen*maxVelocity, newVelocity.y/newVelocityLen*maxVelocity};
    else
        velocity = newVelocity;

    oldPosition = representation.getPosition();
    representation.setPosition(representation.getPosition() + velocity*elapsedTime.asSeconds());
}
    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];

    }
Exemple #24
0
Derivative evaluate(const RigidBody *initial, float t, float dt, const Derivative &d)
{
    State state;
    state.x = initial->_position + d.dx * dt;
    state.v = initial->_velocity + d.dv * dt;
    state.ori = initial->_orientation + d.w * dt;
    state.dori = initial->_angularVelocity + d.dw * dt;

    Derivative output;
    output.dx = state.v;
    output.dv = acceleration();
    output.w = state.dori;
    output.dw = 0;

    return output;
}
Exemple #25
0
 void tick(double dt) {
     for (Body &current : bodies) {
         glm::vec2 acceleration(0.0);
         for (const Body &other : bodies) {
             glm::vec2 to_other = other.position - current.position;
             double distance2 = glm::length2(to_other);
             if(distance2 < 0.0001) {
                 continue;
             }
             acceleration += glm::vec2(G * other.mass / distance2) * glm::normalize(to_other);
         }
         current.velocity += acceleration * glm::vec2(dt);
     }
     for (Body &current : bodies) {
         current.position += current.velocity * glm::vec2(dt);
     }
 }
Exemple #26
0
void Emitter::prepareParticles(){

    // Shotgun stuff
    if(hasFired && isShotgun){
        return;
    }
    hasFired = true;

    for(int i(0); i < density; ++i){
        // Shitty random generation for now
        float rand1 = ((rand()%100)/100.0f)-0.5f;
        float rand2 = ((rand()%100)/100.0f)-0.5f;
        float rand3 = ((rand()%100)/100.0f)-0.5f;

        glm::vec3 position(-1.3f+rand1, 0.0f, rand2);
        // Emitter parented to camera
        // position+=camera->getPosition();
        glm::vec3 velocity(0.0f, 0.01f+(0.01f*rand3), 0.0f);
        glm::vec3 acceleration(0.0f, 0.0f, 0.0f);

        // Random wind interaction for snow particles.
        // if (rand() % 1000){
        //     velocity += glm::vec3(0.001 * (rand() % 5), - abs(0.0005 * (rand() % 5)), 0.001 * (rand() % 5));
        // }

        float rotation = 0.0f;

        // Particle recycling!
        // Weird that the pointer must be explicitly set to 0, but crashes without this
        Particle* ptr = 0;
        if(particles.size() < maxParticles){
            ptr = new Particle(*billboard, shader);
            ptr->setEmissive(particle_texture);
        }
        if(particles.size() > 0 && particles[0]->isDead()){
            ptr = particles[0];
            particles.pop_front();
        }
        if(ptr){
            ptr->setInitialValues(position, velocity, acceleration, rotation, lifespan, Particle::ScalingOption::SCALE_DOWN_WITH_AGE, Particle::FadingOption::FADE_NONE);
            particles.push_back(ptr);
        }
    }
}
Exemple #27
0
int QPanGesture::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QGesture::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    
#ifndef QT_NO_PROPERTIES
     if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QPointF*>(_v) = lastOffset(); break;
        case 1: *reinterpret_cast< QPointF*>(_v) = offset(); break;
        case 2: *reinterpret_cast< QPointF*>(_v) = delta(); break;
        case 3: *reinterpret_cast< qreal*>(_v) = acceleration(); break;
        case 4: *reinterpret_cast< qreal*>(_v) = QPanGesture::d_func()->horizontalVelocity(); break;
        case 5: *reinterpret_cast< qreal*>(_v) = QPanGesture::d_func()->verticalVelocity(); break;
        }
        _id -= 6;
    } else if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: setLastOffset(*reinterpret_cast< QPointF*>(_v)); break;
        case 1: setOffset(*reinterpret_cast< QPointF*>(_v)); break;
        case 3: setAcceleration(*reinterpret_cast< qreal*>(_v)); break;
        case 4: QPanGesture::d_func()->setHorizontalVelocity(*reinterpret_cast< qreal*>(_v)); break;
        case 5: QPanGesture::d_func()->setVerticalVelocity(*reinterpret_cast< qreal*>(_v)); break;
        }
        _id -= 6;
    } else if (_c == QMetaObject::ResetProperty) {
        _id -= 6;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 6;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 6;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 6;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 6;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 6;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
Exemple #28
0
bool SGMFastScanParameters::operator ==(const SGMFastScanParameters &other){
	if( element() == other.element() &&
		runSeconds() == other.runSeconds() &&
		energyStart() == other.energyStart() &&
		energyMidpoint() == other.energyMidpoint() &&
		energyEnd() == other.energyEnd() &&
		velocity() == other.velocity() &&
		velocityBase() == other.velocityBase() &&
		acceleration() == other.acceleration() &&
		scalerTime() == other.scalerTime() &&
		baseLine() == other.baseLine() &&
		undulatorStartStep() == other.undulatorStartStep() &&
		undulatorVelocity() == other.undulatorVelocity() &&
		undulatorRelativeStep() == other.undulatorRelativeStep() &&
		exitSlitDistance() == other.exitSlitDistance() &&
		sgmGrating() == other.sgmGrating()){
		return true;
	}
	return false;
}
Exemple #29
0
Derivative Physics::take_derivative(const State &init_state,
		const Derivative &init_derivative, Body *body_ptr, real_t dt) const {
	// Make a dt step.
	State update_state;
	update_state.position = init_state.position + init_derivative.d_position * dt;
	update_state.velocity = init_state.velocity + init_derivative.d_velocity * dt;
	update_state.angular_position = init_state.angular_position +
								init_derivative.d_angular_position * dt;
	update_state.angular_velocity = init_state.angular_velocity +
							init_derivative.d_angular_velocity * dt;

	Derivative result;
	result.d_position = update_state.velocity;
	result.d_angular_position = update_state.angular_velocity;

	// Compute the new linear and angular acceleration from the new force and torque.
	acceleration(update_state, body_ptr, dt, result);

	return result;
}
Exemple #30
0
 void
 System::acceleration(Object &mainObject,
                      int i,
                      double time,
                      std::string dimension)
 {
    arma::Col<double> tempAcceleration(3);
    arma::Col<double> acceleration(3);
    acceleration.zeros();
    for (int j = 0; j < numberOfObject; ++j)
    {
       if (j!=i)
       {
          const Object tempObject = objectlist[j];
          Distance d;
          arma::Col<double> position1, position2;
          position1 = mainObject.getPosition();
          position2 = tempObject.getPosition()+ time*tempObject.getVelocity();
          double R = d.twoObjects(position1, position2);

          if (dimension == "ly")
          {
             tempAcceleration = -(tempObject.getMass()*
                                  (mainObject.getPosition()-tempObject.getPosition())/
                                  (R*(R*R+epsilon_*epsilon_)));// ly/yr]
          }
          else if(dimension == "AU")
          {
             tempAcceleration = -4*PI*PI*tempObject.getMass()*
                   (mainObject.getPosition()-tempObject.getPosition())/
                   (R*(R*R+epsilon_*epsilon_));// ly/yr]
          }
          else
          {
             std::cout << "dimension must be AU or ly"<< std::endl;
          }
          acceleration += tempAcceleration;
       } //end if
    } //end for
    mainObject.setAcceleration(acceleration);
 }