double HeliumSimpleAnalytical::waveFunction(const mat &r, VMCSolver *solver)
{
    double alpha = solver->getAlpha();
    vec rpos(solver->getNParticles());



    for(int i = 0; i < solver->getNParticles(); i++) {
        double rSingleParticle = 0;
        for(int j = 0; j < solver->getNDimensions(); j++) {
            rSingleParticle += r(i,j) * r(i,j);
        }
        rpos[i] = sqrt(rSingleParticle);
    }







//    cout << "Starting new run" << endl << endl;
//    cout << "detUp is" << solver->determinant()->detUp << endl;
//    cout << "detDown is" << solver->determinant()->detDown << endl;

//    cout << "SlaterDeterminant is " << SD << endl;
//    cout << "Correct wavefunction is: "  << exp(-accu(rpos) * alpha) << endl << endl;

    return SD;//exp(-accu(rpos) * alpha);
}
Example #2
0
void level::insertLifeUpgrade()
{
    double px = ((rand() % 2000)-1000)*(DIMENSION-0.25)/1000.;
    double py = ((rand() % 2000)-1000)*(DIMENSION-0.25)/1000.;
    vector2D rpos(px,py,0,0);
    lifeUpgradeList.push_back(new lifeUpgrade(rpos));
}
Example #3
0
double
DynNewtonian::getSquareCellCollision2(const Particle& part, const Vector & origin, const Vector & width) const
{
    Vector  rpos(part.getPosition() - origin);
    Vector  vel(part.getVelocity());
    Sim->BCs->applyBC(rpos, vel);

    for (size_t iDim = 0; iDim < NDIM; ++iDim)
        if ((vel[iDim] == 0) && (std::signbit(vel[iDim])))
            vel[iDim] = 0;

    double retVal;
    if (vel[0] < 0)
        retVal = -rpos[0] / vel[0];
    else
        retVal = (width[0]-rpos[0]) / vel[0];

    for (size_t iDim = 1; iDim < NDIM; ++iDim)
    {
        double tmpdt((vel[iDim] < 0)
                     ? -rpos[iDim]/vel[iDim]
                     : (width[iDim]-rpos[iDim]) / vel[iDim]);

        if (tmpdt < retVal)
            retVal = tmpdt;
    }

    return retVal;
}
Example #4
0
int
DynNewtonian::getSquareCellCollision3(const Particle& part, const Vector & origin, const Vector & width) const
{
    Vector  rpos(part.getPosition() - origin);
    Vector  vel(part.getVelocity());

    Sim->BCs->applyBC(rpos, vel);

    int retVal(0);
    double time(HUGE_VAL);

    for (size_t iDim = 0; iDim < NDIM; ++iDim)
        if ((vel[iDim] == 0) && (std::signbit(vel[iDim])))
            vel[iDim] = 0;

    for (size_t iDim = 0; iDim < NDIM; ++iDim)
    {
        double tmpdt = ((vel[iDim] < 0)
                        ? -rpos[iDim]/vel[iDim]
                        : (width[iDim]-rpos[iDim]) / vel[iDim]);

        if (tmpdt < time)
        {
            time = tmpdt;
            retVal = (vel[iDim] < 0) ? -(iDim+1) : (iDim+1);
        }
    }

    if (((retVal < 0) && (vel[abs(retVal)-1] > 0))
            || ((retVal > 0) && (vel[abs(retVal)-1] < 0)))
        M_throw() << "Found an error! retVal " << retVal
                  << " vel is " << vel[abs(retVal)-1];

    return retVal;
}
Example #5
0
void LineBuilder::strip_add_arc(Vector2 center, float angle_delta, Orientation orientation) {

	// Take the two last vertices and extrude an arc made of triangles
	// that all share one of the initial vertices

	Orientation opposite_orientation = orientation == UP ? DOWN : UP;
	Vector2 vbegin = vertices[_last_index[opposite_orientation]] - center;
	float radius = vbegin.length();
	float angle_step = Math_PI / static_cast<float>(round_precision);
	float steps = Math::abs(angle_delta) / angle_step;

	if (angle_delta < 0.f)
		angle_step = -angle_step;

	float t = vbegin.angle_to(Vector2(1, 0));
	float end_angle = t + angle_delta;
	Vector2 rpos(0, 0);

	// Arc vertices
	for (int ti = 0; ti < steps; ++ti, t += angle_step) {
		rpos = center + Vector2(Math::cos(t), Math::sin(t)) * radius;
		strip_add_tri(rpos, orientation);
	}

	// Last arc vertice
	rpos = center + Vector2(Math::cos(end_angle), Math::sin(end_angle)) * radius;
	strip_add_tri(rpos, orientation);
}
double HeliumJastrowAnalytical::waveFunction(const mat &r, VMCSolver *solver)
{
    double nParticles = solver->getNParticles();
    double nDimensions = solver->getNDimensions();
    double alpha = solver->getAlpha();
    double beta = solver->getBeta();


    //double r12;
    vec rpos(nParticles);
    for(int i = 0; i < nParticles; i++) {
        double rSingleParticle = 0;
        for(int j = 0; j < nDimensions; j++) {
            rSingleParticle += r(i,j) * r(i,j);
        }
        rpos[i] = sqrt(rSingleParticle);
    }
    // assuming 2 particles
    //   (ta fra elektron-elektron pot.)
    //r12 = abs(rpos[0] - rpos[1]);
    double r12 = 0;
    for(int i = 0; i < nParticles; i++) {
        for(int j = i + 1; j < nParticles; j++) {
            r12 = 0;
            for(int k = 0; k < nDimensions; k++) {
                r12 += (r(i,k) - r(j,k)) * (r(i,k) - r(j,k));

            }
            r12 = sqrt(r12);
        }
    }
//    cout << exp(r12 / (2.0*(1 + beta * r12))) << endl;
    return exp(-accu(rpos) * alpha) * exp(r12 / (2.0*(1 + beta * r12))) ;
}
Example #7
0
void ZCompressor::Deflate(uint8 level)
{
    if( _iscompressed || (!size()) || level>9 )
        return;

    char *buf;
    buf=new char[size()+8];

    uint32 newsize=size(),oldsize=size();
    reserve(size()+8);

    _compress((void*)buf, &newsize, (void*)contents(),size(),level);

    if(!newsize)
        return;

    resize(newsize);
    rpos(0);
    wpos(0);
    append(buf,newsize);
    delete [] buf;

    _iscompressed=true;

    _real_size=oldsize;
}
Example #8
0
double
DynNewtonian::getSquareCellCollision2(const Particle& part, const Vector & origin, const Vector & width) const
{
    Vector  rpos(part.getPosition() - origin);
    Vector  vel(part.getVelocity());
    Sim->BCs->applyBC(rpos, vel);

#ifdef DYNAMO_DEBUG
    for (size_t iDim = 0; iDim < NDIM; ++iDim)
        if ((vel[iDim] == 0) && (std::signbit(vel[iDim])))
            M_throw() << "You have negative zero velocities, don't use them.";
#endif

    double retVal;
    if (vel[0] < 0)
        retVal = -rpos[0] / vel[0];
    else
        retVal = (width[0]-rpos[0]) / vel[0];

    for (size_t iDim = 1; iDim < NDIM; ++iDim)
    {
        double tmpdt((vel[iDim] < 0)
                     ? -rpos[iDim]/vel[iDim]
                     : (width[iDim]-rpos[iDim]) / vel[iDim]);

        if (tmpdt < retVal)
            retVal = tmpdt;
    }

    return retVal;
}
Example #9
0
LuaPacket::LuaPacket(lua_State* L) : ByteBuffer(0), changed_(false)
{
    uint32_t opcode = static_cast<uint32_t>(luaL_checknumber(L, 1));
    ByteBuffer::SetOpcode(opcode);
    rpos(sizeof(uint32_t));
    wpos(sizeof(uint32_t));
}
Example #10
0
void level::insertFireUpgrade()
{
    double px = ((rand() % 2000)-1000)*(DIMENSION-0.25)/1000.;
    double py = ((rand() % 2000)-1000)*(DIMENSION-0.25)/1000.;
    vector2D rpos(px,py,0,0);
    int wtype = rand() % WEAPONS;
    fireUpgradeList.push_back(new fireUpgrade(rpos,wtype));
}
Example #11
0
//-------------------------------------------------------------------------------------
int UDPPacket::recvFromEndPoint(EndPoint & ep, Address* pAddr)
{
	int len = ep.recvfrom(data(), PACKET_MAX_SIZE_UDP,
		(u_int16_t*)&pAddr->port, (u_int32_t*)&pAddr->ip);

	KBE_ASSERT(rpos() == 0);
	wpos(len);
	return len;
}
Example #12
0
void level::insertSpiralShip()
{
    double px = ((rand() % 2000)-1000)*(DIMENSION-0.4)/1000.;
    double py = ((rand() % 2000)-1000)*(DIMENSION-0.4)/1000.;
    vector2D rpos(px,py,0,0);
    double sx = 0.001;
    double sy = 0.001;
    vector2D resp(sx,sy,0,0);
    enemyList.push_back(new spiralShip(rpos,resp));
}
Example #13
0
//-------------------------------------------------------------------------------------
int TCPPacket::recvFromEndPoint(EndPoint & ep, Address* pAddr)
{
	//KBE_ASSERT(MessageHandlers::pMainMessageHandlers != NULL && "Must set up a MainMessageHandlers!\n");
	int len = ep.recv(data(), PACKET_MAX_SIZE_TCP * 4);
	KBE_ASSERT(rpos() == 0);
	wpos(len);

	// DEBUG_MSG("TCPPacket::recvFromEndPoint: datasize=%d, wpos=%d.\n", len, wpos());
	return len;
}
Example #14
0
void level::insertDummyShip()
{
    double px = ((rand() % 2000)-1000)*(DIMENSION-0.25)/1000.;
    double py = ((rand() % 2000)-1000)*(DIMENSION-0.25)/1000.;
    vector2D rpos(px,py,0,0);
    double sx = ((rand() % 2000)-1000)/100000.;
    double sy = ((rand() % 2000)-1000)/100000.;
    vector2D resp(sx,sy,0,0);
    enemyList.push_back(new dummyship(rpos,resp));
}
Example #15
0
void MemoryStream::print_storage()
{
	FString fbuffer;
	uint32 trpos = rpos_;

	DEBUG_MSG("MemoryStream::print_storage(): STORAGE_SIZE: %lu, rpos=%lu.", (unsigned long)wpos(), (unsigned long)rpos());

	for (uint32 i = rpos(); i < wpos(); ++i)
	{
		fbuffer.AppendInt((int)read<uint8>(i));
		fbuffer += TEXT(" ");
	}

	DEBUG_MSG("%s", *fbuffer);

	rpos_ = trpos;
}
Example #16
0
int
DynNewtonian::getSquareCellCollision3(const Particle& part, const Vector & origin, const Vector & width) const
{
    Vector  rpos(part.getPosition() - origin);
    Vector  vel(part.getVelocity());

    Sim->BCs->applyBC(rpos, vel);

    int retVal(0);
    double time(HUGE_VAL);

#ifdef DYNAMO_DEBUG
    for (size_t iDim = 0; iDim < NDIM; ++iDim)
        if ((vel[iDim] == 0) && (std::signbit(vel[iDim])))
            M_throw() << "You have negative zero velocities, dont use them."
                      << "\nPlease think of the neighbour lists.";
#endif

    for (size_t iDim = 0; iDim < NDIM; ++iDim)
    {
        double tmpdt = ((vel[iDim] < 0)
                        ? -rpos[iDim]/vel[iDim]
                        : (width[iDim]-rpos[iDim]) / vel[iDim]);

        if (tmpdt < time)
        {
            time = tmpdt;
            retVal = (vel[iDim] < 0) ? -(iDim+1) : (iDim+1);
        }
    }

    if (((retVal < 0) && (vel[abs(retVal)-1] > 0))
            || ((retVal > 0) && (vel[abs(retVal)-1] < 0)))
        M_throw() << "Found an error! retVal " << retVal
                  << " vel is " << vel[abs(retVal)-1];

    return retVal;
}
Example #17
0
void ZCompressor::Inflate(void)
{
    if( (!_iscompressed) || (!_real_size) || (!size()))
        return;

    uLongf origsize=_real_size;
    int8 result;
    uint8 *target=new uint8[_real_size];
    wpos(0);
    rpos(0);
    result = uncompress(target, &origsize, (uint8*)contents(), size());
    if( result!=Z_OK || origsize!=_real_size)
    {
        logerror("ZCompressor: Inflate error! result=%d cursize=%u origsize=%u realsize=%u\n",result,size(),origsize,_real_size);
        delete [] target;
        return;
    }
    clear();
    append(target,origsize);
    delete [] target;
    _real_size=0;
    _iscompressed=false;

}
Example #18
0
LuaPacket::LuaPacket(CDataStore* data) : changed_(false)
{
    append(data->Buffer, data->Length);
    rpos(sizeof(uint32_t));
    wpos(sizeof(uint32_t));
}
Example #19
0
  int
  DynGravity::getSquareCellCollision3(const Particle& part, 
					     const Vector & origin, 
					     const Vector & width) const
  {
    Vector  rpos(part.getPosition() - origin);
    Vector  vel(part.getVelocity());

    Sim->BCs->applyBC(rpos, vel);

    int retVal(0);
    double time(std::numeric_limits<float>::infinity());
  
#ifdef DYNAMO_DEBUG
    for (size_t iDim = 0; iDim < NDIM; ++iDim)
      if ((vel[iDim] == 0) && (std::signbit(vel[iDim])))
	M_throw() << "You have negative zero velocities, dont use them."
		  << "\nPlease think of the neighbour lists.";
#endif

    for (size_t iDim = 0; iDim < NDIM; ++iDim)
      if ((g[iDim] != 0) && part.testState(Particle::DYNAMIC))
	{
	  //First check the "upper" boundary that may have no roots
	  double rdot = (g[iDim] < 0) ? rpos[iDim] - width[iDim]: rpos[iDim];
	  double arg = vel[iDim] * vel[iDim] - 2 * rdot * g[iDim];
	  double upperRoot1(std::numeric_limits<float>::infinity()), upperRoot2(std::numeric_limits<float>::infinity());
	
	  if (arg >= 0)
	    {
	      double t = -(vel[iDim] + ((vel[iDim]<0) ? -1: 1) * std::sqrt(arg));
	      upperRoot1 = t / g[iDim];
	      upperRoot2 = 2 * rdot / t;
	      if (upperRoot2 < upperRoot1) std::swap(upperRoot2, upperRoot1);
	    }

	
	  //Now the lower boundary which always has roots
	  rdot = (g[iDim] < 0) ? rpos[iDim] : rpos[iDim]-width[iDim];
	  arg = vel[iDim] * vel[iDim] - 2 * rdot * g[iDim];
	  double lowerRoot1(std::numeric_limits<float>::infinity()), lowerRoot2(std::numeric_limits<float>::infinity());
	  if (arg >= 0)
	    {
	      double t = -(vel[iDim] + ((vel[iDim]<0) ? -1: 1) * std::sqrt(arg));
	      lowerRoot1 = t / g[iDim];
	      lowerRoot2 = 2 * rdot / t;
	      if (lowerRoot2 < lowerRoot1) std::swap(lowerRoot2, lowerRoot1);
	    }

	  //Now, if the velocity is "up", and the upper roots exist,
	  //then pick the shortest one
	  if (!((g[iDim] < 0) - (vel[iDim] > 0)))
	    if (upperRoot1 < time)
	      {
		time = upperRoot1;
		retVal = (g[iDim] < 0) ? (iDim + 1) : -(iDim + 1);
	      }

	  //Otherwise its usually the latest lowerRoot
	  if (lowerRoot2 < time)
	    {
	      time = lowerRoot2;
	      retVal = (g[iDim] < 0) ? - (iDim + 1) : (iDim + 1);
	    }
	}  
      else
	{
	  double tmpdt = ((vel[iDim] < 0) 
			  ? -rpos[iDim] / vel[iDim] 
			  : (width[iDim] - rpos[iDim]) / vel[iDim]);

	  if (tmpdt < time)
	    {
	      time = tmpdt;
	      retVal = (vel[iDim] < 0) ? - (iDim + 1) : iDim + 1;
	    }
	}

    return retVal;
  }
Example #20
0
int LuaPacket::Dump(lua_State* L)
{
    // Save old rpos and seek to the beginning (without the opcode)
    size_t oldrpos = rpos();
    rpos(sizeof(uint32_t));

    uint32_t pushed = 0;

    std::string value = lua_tostring(L, 1);
    std::vector<std::string> parts = Utils::Split(value, ' ');

    if (parts.size() < 1)
        return luaL_argerror(L, 1, "Invalid dump format");

    for (uint32_t i = 0; i < parts.size(); i++)
    {
        if (parts[i] == "int8")
        {
            ReadInt8(L);
            pushed++;
        }
        else if (parts[i] == "int16")
        {
            ReadInt16(L);
            pushed++;
        }
        else if (parts[i] == "int32")
        {
            ReadInt32(L);
            pushed++;
        }
        else if (parts[i] == "int64")
        {
            ReadInt64(L);
            pushed++;
        }
        else if (parts[i] == "int128")
        {
            ReadInt128(L);
            pushed++;
        }
        else if (parts[i] == "float")
        {
            ReadFloat(L);
            pushed++;
        }
        else if (parts[i] == "double")
        {
            ReadDouble(L);
            pushed++;
        }
        else if (parts[i] == "string")
        {
            ReadString(L);
            pushed++;
        }
        else if (parts[i] == "bit")
        {
            ReadBit(L);
            pushed++;
        }
    }

    // Restore rpos
    rpos(oldrpos);
    return pushed;
}
Example #21
0
int LuaPacket::SetReadPosition(lua_State* L)
{
    uint32_t position = static_cast<uint32_t>(luaL_checknumber(L, 1));
    rpos(position);
    return 0;
}
Example #22
0
void LineBuilder::new_arc(Vector2 center, Vector2 vbegin, float angle_delta, Color color, Rect2 uv_rect) {

	// Make a standalone arc that doesn't use existing vertices,
	// with undistorted UVs from within a square section

	float radius = vbegin.length();
	float angle_step = Math_PI / static_cast<float>(round_precision);
	float steps = Math::abs(angle_delta) / angle_step;

	if (angle_delta < 0.f)
		angle_step = -angle_step;

	float t = vbegin.angle_to(Vector2(1, 0));
	float end_angle = t + angle_delta;
	Vector2 rpos(0, 0);
	float tt_begin = -Math_PI / 2.f;
	float tt = tt_begin;

	// Center vertice
	int vi = vertices.size();
	vertices.push_back(center);
	if (_interpolate_color)
		colors.push_back(color);
	if (texture_mode != LINE_TEXTURE_NONE)
		uvs.push_back(interpolate(uv_rect, Vector2(0.5f, 0.5f)));

	// Arc vertices
	for (int ti = 0; ti < steps; ++ti, t += angle_step) {
		Vector2 sc = Vector2(Math::cos(t), Math::sin(t));
		rpos = center + sc * radius;

		vertices.push_back(rpos);
		if (_interpolate_color)
			colors.push_back(color);
		if (texture_mode != LINE_TEXTURE_NONE) {
			Vector2 tsc = Vector2(Math::cos(tt), Math::sin(tt));
			uvs.push_back(interpolate(uv_rect, 0.5f * (tsc + Vector2(1.f, 1.f))));
			tt += angle_step;
		}
	}

	// Last arc vertice
	Vector2 sc = Vector2(Math::cos(end_angle), Math::sin(end_angle));
	rpos = center + sc * radius;
	vertices.push_back(rpos);
	if (_interpolate_color)
		colors.push_back(color);
	if (texture_mode != LINE_TEXTURE_NONE) {
		tt = tt_begin + angle_delta;
		Vector2 tsc = Vector2(Math::cos(tt), Math::sin(tt));
		uvs.push_back(interpolate(uv_rect, 0.5f * (tsc + Vector2(1.f, 1.f))));
	}

	// Make up triangles
	int vi0 = vi;
	for (int ti = 0; ti < steps; ++ti) {
		indices.push_back(vi0);
		indices.push_back(++vi);
		indices.push_back(vi + 1);
	}
}
Example #23
0
int LuaPacket::GetReadPosition(lua_State* L)
{
    lua_pushnumber(L, rpos());
    return 1;
}
Example #24
0
int LuaPacket::SyncWritePosition(lua_State* L)
{
    wpos(rpos());
    return 0;
}
Example #25
0
int LuaPacket::SyncReadPosition(lua_State* L)
{
    rpos(wpos());
    return 0;
}
Example #26
0
	void resetPacket(void)
	{
		wpos(0);
		rpos(0);
		// memset(data(), 0, size());
	};
Example #27
0
	virtual size_t totalSize() const { return wpos() - rpos(); }
Example #28
0
double
DynGravity::getSquareCellCollision2(const Particle& part,
                                    const Vector & origin,
                                    const Vector & width) const
{
    Vector rpos(part.getPosition() - origin);
    Vector vel(part.getVelocity());
    Sim->BCs->applyBC(rpos, vel);

#ifdef DYNAMO_DEBUG
    for (size_t iDim = 0; iDim < NDIM; ++iDim)
        if ((vel[iDim] == 0) && (std::signbit(vel[iDim])))
            M_throw() << "You have negative zero velocities, dont use them."
                      << "\nPlease think of the neighbour lists.";
#endif

    double retVal = HUGE_VAL;

    for (size_t iDim = 0; iDim < NDIM; ++iDim)
        if ((g[iDim] != 0) && part.testState(Particle::DYNAMIC))
        {
            //First check the "upper" boundary that may have no roots
            double r = (g[iDim] < 0) ? rpos[iDim] - width[iDim] : rpos[iDim];
            double arg = vel[iDim] * vel[iDim] - 2 * r * g[iDim];
            double upperRoot1(HUGE_VAL), upperRoot2(HUGE_VAL);

            if (arg >= 0)
            {
                double t = -(vel[iDim] + ((vel[iDim]<0) ? -1: 1) * std::sqrt(arg));
                upperRoot1 = t / g[iDim];
                upperRoot2 = 2 * r / t;
                if (upperRoot2 < upperRoot1) std::swap(upperRoot2, upperRoot1);
            }


            //Now the lower boundary which always has roots
            r = (g[iDim] < 0) ? rpos[iDim] : rpos[iDim] - width[iDim];
            arg = vel[iDim] * vel[iDim] - 2 * r * g[iDim];
            double lowerRoot1(HUGE_VAL), lowerRoot2(HUGE_VAL);
            if (arg >= 0)
            {
                double t = -(vel[iDim] + ((vel[iDim]<0) ? -1: 1) * std::sqrt(arg));
                lowerRoot1 = t / g[iDim];
                lowerRoot2 = 2 * r / t;
                if (lowerRoot2 < lowerRoot1) std::swap(lowerRoot2, lowerRoot1);
            }

            double root = HUGE_VAL;
            //Now, if the velocity is "up", and the upper roots exist,
            //then pick the shortest one
            if (!((g[iDim] < 0) - (vel[iDim] > 0))
                    && (upperRoot1 != HUGE_VAL))
                root = upperRoot1;

            //Otherwise its usually the latest lowerRoot
            if (root == HUGE_VAL)
                root = lowerRoot2;

            if (root < retVal)
                retVal = root;
        }
        else
        {
            double tmpdt((vel[iDim] < 0)
                         ? -rpos[iDim]/vel[iDim]
                         : (width[iDim]-rpos[iDim]) / vel[iDim]);

            if (tmpdt < retVal)
                retVal = tmpdt;
        }

    return retVal;
}