void p2p (PointAccum *one, PointAccum *other)
{
  if (one != other)
    {
      VsgVector3d tmp;
      VsgVector3d tmp1;
      VsgVector3d tmp2;
      gdouble r, inv_r, inv_r3;

      /* destination - source */
      vsg_vector3d_sub (&one->vector, &other->vector, &tmp);

      r = vsg_vector3d_norm (&tmp);

      if (r > epsilon)
        {
          inv_r = 1. / r;
          inv_r3 = inv_r*inv_r*inv_r;

/*           one->accum += inv_r * other->density; */
          vsg_vector3d_scalp (&tmp, - inv_r3*other->density, &tmp1);
          vsg_vector3d_add (&one->field, &tmp1, &one->field);

/*           other->accum += inv_r * one->density; */
          vsg_vector3d_scalp (&tmp, inv_r3*one->density, &tmp2);
          vsg_vector3d_add (&other->field, &tmp2, &other->field);

/*           g_printerr ("%d : p2p %d %d ", rk, one->id, other->id); */
/*           vsg_vector3d_write (&one->vector, stderr); */
/*           g_printerr (" "); */
/*           vsg_vector3d_write (&one->field, stderr); */
/*           g_printerr ("\n"); */
        }
    }
}
static void p2p (PointAccum *one, PointAccum *other)
{
  if (one != other)
    {
      VsgVector3d tmp;
      VsgVector3d tmp1;
      VsgVector3d tmp2;
      gdouble r, inv_r, inv_r3;

      /* destination - source */
      vsg_vector3d_sub (&one->vector, &other->vector, &tmp);

      r = vsg_vector3d_norm (&tmp);

      if (r > epsilon)
        {
          inv_r = 1. / r;
          inv_r3 = inv_r*inv_r*inv_r;

/*           one->accum += inv_r * other->density; */
          vsg_vector3d_scalp (&tmp, - inv_r3*other->density, &tmp1);
          vsg_vector3d_add (&one->field, &tmp1, &one->field);

/*           other->accum += inv_r * one->density; */
          vsg_vector3d_scalp (&tmp, inv_r3*one->density, &tmp2);
          vsg_vector3d_add (&other->field, &tmp2, &other->field);
        }
    }
}
Beispiel #3
0
static void check (const gchar *log,
                   AranSphericalSeriesd *ass, gdouble radius,
		   VsgVector3d *center,
		   gcomplex128 (*f) (VsgVector3d *x))
{
  guint i, j, k;
  gdouble t, p;
  gcomplex128 yres, yref, err;
  gdouble r, cost, sint, cosp, sinp;

  for (i=0; i<N ; i ++)
    {
      p = 2.*G_PI * i/(N-1.);
      cosp = cos (p);
      sinp = sin (p);

      for (j=0; j<N; j ++)
	{
	  t = G_PI * j/(N-1.);
	  cost = cos (t);
	  sint = sin (t);

	  for (k=0; k<N; k ++)
	    {
	      VsgVector3d vec;
	      r = radius + radius * k/(N-1.);

	      yres = aran_spherical_seriesd_evaluate_internal (ass, r,
							       cost, sint,
							       cosp, sinp);

	      vsg_vector3d_from_spherical_internal (&vec, r,
						    cost, sint,
						    cosp, sinp);
	      vsg_vector3d_add (&vec, center, &vec);

	      yref = f (&vec);

	      err = yref-yres;

	      if (yref != 0.) err /= yref;

	      if (cabs (err) > epsilon && cabs(yref) > epsilon)
		{
		  g_printerr ("Error %s (%f,%f,%f) : " \
                              "(%e+%ej), (%e+%ej) -> %e\n",
                              log,
			      r, t, p,
			      creal (yref), cimag (yref),
			      creal (yres), cimag (yres),
			      cabs (err));
		}
	    }
	}
    }
}
void l2p (const VsgPRTree3dNodeInfo *devel_node, AranDevelopment3d *devel,
          PointAccum *particle)
{
  VsgVector3d tmp;

  aran_development3d_local_gradient_evaluate (devel_node, devel,
                                              &particle->vector,
                                              &tmp);

  vsg_vector3d_add (&particle->field, &tmp, &particle->field);
}
static void l2p (const VsgVector3d *center, AranDevelopment3d *devel,
		 PointAccum *particle)
{
  VsgVector3d tmp;

/*   particle->accum += aran_development3d_local_evaluate (center, devel, */
/* 							&particle->vector); */

  aran_development3d_local_gradient_evaluate (center, devel,
                                              &particle->vector,
                                              &tmp);

  vsg_vector3d_add (&particle->field, &tmp, &particle->field);
}
Beispiel #6
0
void m2p (const VsgPRTree3dNodeInfo *devel_node, AranDevelopment3d *devel,
          PointAccum *particle)
{
  VsgVector3d tmp;

  /* g_printerr ("%d : m2p %lu \n", rk, particle->id); */

  aran_development3d_m2pv (devel_node, devel, &particle->vector, &tmp);

  vsg_vector3d_add (&particle->field, &tmp, &particle->field);

  /* g_printerr (" f="); */
  /* vsg_vector3d_write (&particle->field, stderr); */
  /* g_printerr (" \n"); */
}
void point_accum_visit_bw_reduce (PointAccum *a, PointAccum *b,
                                  gpointer user_data)
{
/*   g_printerr ("%d : bw red id=%d a=", */
/*               rk, b->id); */
/*   vsg_vector3d_write (&a->field, stderr); */
/*   g_printerr (" b="); */
/*   vsg_vector3d_write (&b->field, stderr); */

  vsg_vector3d_add (&a->field, &b->field, &b->field);

/*   g_printerr (" a+b="); */
/*   vsg_vector3d_write (&b->field, stderr); */
/*   g_printerr ("\n"); */
/*   fflush (stderr); */
}
Beispiel #8
0
static void check (const gchar *log,
                   AranSphericalSeriesd *ass, gdouble radius,
		   VsgVector3d *center,
		   void (*f) (VsgVector3d *x, VsgVector3d *grad))
{
  guint i, j, k;
  gdouble t, p;
  gdouble err;
  gdouble r, cost, sint, cosp, sinp;
  gcomplex128 dr, dt, dp;

  for (i=0; i<N ; i ++)
    {
      p = 2.*G_PI * i/(N-1.);
      cosp = cos (p);
      sinp = sin (p);

      for (j=0; j<N; j ++)
	{
	  t = G_PI * j/(N-1.);
	  cost = cos (t);
	  sint = sin (t);

	  for (k=0; k<N; k ++)
	    {
	      VsgVector3d vec;
	      VsgVector3d vref;
	      VsgVector3d vres;
	      VsgVector3d verr;

	      r = radius * k/(N-1.);

	      vsg_vector3d_from_spherical_internal (&vec, r,
						    cost, sint,
						    cosp, sinp);

/*               aran_spherical_seriesd_gradient_evaluate (ass, &vec, */
/*                                                               &vres); */

              aran_spherical_seriesd_gradient_evaluate_internal (ass,
                                                                 r,
                                                                 cost, sint,
                                                                 cosp, sinp,
                                                                 &dr, &dt, &dp);
              local_to_cartesian (r, cost, sint, cosp, sinp,
                                  creal (dr), creal (dt), creal (dp),
                                  &vres);

              
              vsg_vector3d_scalp (&vres, -1., &vres);

	      vsg_vector3d_add (&vec, center, &vec);

	      f (&vec, &vref);

	      vsg_vector3d_sub (&vref, &vres, &verr);

              err = vsg_vector3d_norm (&verr) / vsg_vector3d_norm (&vref);

	      if (fabs (err) > epsilon || !finite (err))
		{
		  g_printerr ("Error %s (%f,%f,%f) : " \
                              "(%f,%f,%f) != (%f,%f,%f) -> %e\n",
                              log,
			      r, t, p,
/* 			      vec.x, vec.y, vec.z, */
			      vref.x, vref.y, vref.z,
			      vres.x, vres.y, vres.z,
			      fabs (err));
		}
	    }
	}
    }
}