Position Functions   ====================================================================== */void MobileNode::start(){	Scheduler& s = Scheduler::instance();	if(random_motion_ == 0) {		log_movement();		return;	}	assert(initialized());	random_position();#ifdef DEBUG        fprintf(stderr, "%d - %s: calling random_destination()\n",                address_, __PRETTY_FUNCTION__);#endif	random_destination();	s.schedule(&pos_handle_, &pos_intr_, position_update_interval_);}void MobileNode::log_movement(){        if (!log_target_) 		return;	Scheduler& s = Scheduler::instance();	sprintf(log_target_->pt_->buffer(),		"M %.5f %d (%.2f, %.2f, %.2f), (%.2f, %.2f), %.2f",		s.clock(), address_, X_, Y_, Z_, destX_, destY_, speed_);	log_target_->pt_->dump();#ifdef MIT_uAMPS#if 0	sprintf(log_target->buffer(),		"M %.5f %d (%.2f, %.2f, %.2f), (%.2f, %.2f), %.2f",		s.clock(), index_, X, Y, Z, destX, destY, speed);	log_target->dump();#endif#endif}voidMobileNode::log_energy(int flag){	if (!log_target_) 		return;	Scheduler &s = Scheduler::instance();	if (flag) {		sprintf(log_target_->pt_->buffer(),"N -t %f -n %d -e %f", s.clock(),			address_, energy_model_->energy()); 	} else {		sprintf(log_target_->pt_->buffer(),"N -t %f -n %d -e 0 ", s.clock(),			address_); 	}	log_target_->pt_->dump();}//void//MobileNode::logrttime(double t)//{//	last_rt_time_ = (int)t;//}voidMobileNode::bound_position(){	double minX;	double maxX;	double minY;	double maxY;	int recheck = 1;	assert(T_ != 0);	minX = T_->lowerX();	maxX = T_->upperX();	minY = T_->lowerY();	maxY = T_->upperY();	while (recheck) {		recheck = 0;		if (X_ < minX) {			X_ = minX + (minX - X_);			recheck = 1;		}		if (X_ > maxX) {			X_ = maxX - (X_ - maxX);			recheck = 1;		}		if (Y_ < minY) {			Y_ = minY + (minY - Y_);			recheck = 1;		}		if (Y_ > maxY) {			Y_ = maxY- (Y_ - maxY);			recheck = 1;		}		if (recheck) {			fprintf(stderr, "Adjust position of node %d\n",address_);		}	}}intMobileNode::set_destination(double x, double y, double s){	assert(initialized());	if(x >= T_->upperX() || x <= T_->lowerX())		return -1;	if(y >= T_->upperY() || y <= T_->lowerY())		return -1;		update_position();	// figure out where we are now		destX_ = x;	destY_ = y;	speed_ = s;		dX_ = destX_ - X_;	dY_ = destY_ - Y_;	dZ_ = 0.0;		// this isn't used, since flying isn't allowed	if (destX_ != X_ || destY_ != Y_) {		// normalize dx, dy to unit len		double len = sqrt( (dX_ * dX_) + (dY_ * dY_) );		dX_ /= len;		dY_ /= len;	}  	position_update_time_ = Scheduler::instance().clock();#ifdef DEBUG	fprintf(stderr, "%d - %s: calling log_movement()\n", 		address_, __FUNCTION__);#endif	log_movement();	/* update gridkeeper */	if (GridKeeper::instance()){		GridKeeper* gp =  GridKeeper::instance();		gp-> new_moves(this);	}                     	if (namChan_ != 0) {		sprintf(nwrk_,     			"n -t %f -s %d -x %f -y %f -U %f -V %f -T %f",			Scheduler::instance().clock(),			nodeid_,			X_, Y_,			speed_ * dX_, speed_ * dY_,			((speed_*dX_) != 0) ? 				(destX_-X_)/(speed_*dX_) : speed_*dX_			);   		namdump();         	}	return 0;}void MobileNode::update_position(){	double now = Scheduler::instance().clock();	double interval = now - position_update_time_;	double oldX = X_, oldY = Y_;	if ((interval == 0.0)&&(position_update_time_!=0))		return;         // ^^^ for list-based imprvmnt 	// CHECK, IF THE SPEED IS 0, THEN SKIP, but usually it's not 0	X_ += dX_ * (speed_ * interval);	Y_ += dY_ * (speed_ * interval);	if ((dX_ > 0 && X_ > destX_) || (dX_ < 0 && X_ < destX_))	  X_ = destX_;		// correct overshoot (slow? XXX)	if ((dY_ > 0 && Y_ > destY_) || (dY_ < 0 && Y_ < destY_))	  Y_ = destY_;		// correct overshoot (slow? XXX)		/* list based improvement */	if(oldX != X_)// || oldY != Y_)		T_->updateNodesList(this, oldX);//, oldY);	// COMMENTED BY -VAL- // bound_position();	// COMMENTED BY -VAL- // Z_ = T_->height(X_, Y_);#if 0	fprintf(stderr, "Node: %d, X: %6.2f, Y: %6.2f, Z: %6.2f, time: %f\n",		address_, X_, Y_, Z_, now);#endif	position_update_time_ = now;}voidMobileNode::random_position(){	if (T_ == 0) {		fprintf(stderr, "No TOPOLOGY assigned\n");		exit(1);	}	X_ = Random::uniform() * T_->upperX();	Y_ = Random::uniform() * T_->upperY();	Z_ = T_->height(X_, Y_);	position_update_time_ = 0.0;}voidMobileNode::random_destination(){	if (T_ == 0) {		fprintf(stderr, "No TOPOLOGY assigned\n");		exit(1);	}	random_speed();#ifdef DEBUG        fprintf(stderr, "%d - %s: calling set_destination()\n",                address_, __FUNCTION__);#endif	(void) set_destination(Random::uniform() * T_->upperX(),                               Random::uniform() * T_->upperY(),                               speed_);}voidMobileNode::random_direction(){	/* this code isn't used anymore -dam 1/22/98 */	double len;	dX_ = (double) Random::random();	dY_ = (double) Random::random();	len = sqrt( (dX_ * dX_) + (dY_ * dY_) );	dX_ /= len;	dY_ /= len;	dZ_ = 0.0;				// we're not flying...	/*	 * Determine the sign of each component of the	 * direction vector.	 */	if (X_ > (T_->upperX() - 2*T_->resol())) {		if (dX_ > 0) 			dX_ = -dX_;	} else if (X_ < (T_->lowerX() + 2*T_->resol())) {		if (dX_ < 0) 			dX_ = -dX_;	} else if (Random::uniform() <= 0.5) {		dX_ = -dX_;	}	if (Y_ > (T_->upperY() - 2*T_->resol())) {		if (dY_ > 0) 			dY_ = -dY_;	} else if (Y_ < (T_->lowerY() + 2*T_->resol())) {		if (dY_ < 0) 			dY_ = -dY_;	} else if(Random::uniform() <= 0.5) {		dY_ = -dY_;	}#if 0	fprintf(stderr, "Location: (%f, %f), Direction: (%f, %f)\n",		X_, Y_, dX_, dY_);#endif}voidMobileNode::random_speed(){	speed_ = Random::uniform() * MAX_SPEED;}doubleMobileNode::distance(MobileNode *m){	update_position();		// update my position	m->update_position();		// update m's position        double Xpos = (X_ - m->X_) * (X_ - m->X_);        double Ypos = (Y_ - m->Y_) * (Y_ - m->Y_);	double Zpos = (Z_ - m->Z_) * (Z_ - m->Z_);        return sqrt(Xpos + Ypos + Zpos);}doubleMobileNode::propdelay(MobileNode *m){	return distance(m) / SPEED_OF_LIGHT;}void MobileNode::idle_energy_patch(float /*total*/, float /*P_idle*/){}