Ejemplo n.º 1
0
void hectate_fiber_body(FiberManager *my_manager) {
  Context context(my_manager);
  context.setRoot(setup_root());
  my_context = &context;
  
  auto arg = my_manager->getArgs();

  run_file("./init.h6x", context, false);
  
  for (int i = 1; i < arg.argc; i++) {
    if (strcmp(arg.argv[i], "-") == 0) {
      REPL(context);
    }
    else {
      run_file(arg.argv[i], context);
    }
  }

  if (arg.argc <= 1) {
    //have no args
    REPL(context);
  }
  
}
Ejemplo n.º 2
0
int main(int argc, const char *argv[])
{
  float increment_x, increment_y;
  int pixel_x = 512, pixel_y = 512, it;
  unsigned int rpp = 500;
  int ncells = 4;
  float accuracy = 0.6;
  count = 0;
  root = NULL;
  curr = NULL;
  
  // Load relevant settings and data
  if (argc < 2) error("Requires argument with lens positions and optional mass");
  setup_constants();
  read_lenses(argv[1]);
  
  setup_root(-lens_rad, lens_rad, lens_rad, -lens_rad, ncells);
  
  build_tree(ncells, root);
  calculate_cm(root, ncells);

  //printf("All cells\n");
  //printf("index, centre mass x, centre mass y, total mass\n"); 
  remove_empty_cells(root, ncells);
  //print_tree(root, ncells);

  fprintf(stderr, "X %f and Y %f\n", image_scale_x, image_scale_y);
  increment_x = (image_scale_x * 2) / pixel_x;
  increment_y = (image_scale_y * 2) / pixel_y;
  fprintf(stderr, "Increments for X %f and Y %f\n", increment_x, increment_y);

  unsigned int *results = (int *)calloc(pixel_x * pixel_y, sizeof(unsigned int));
  if (!results) error("calloc failed in allocating the result array");
  int highest = 0;

  // Fire off the light rays and record their end locations
  int complete_iterations = 0;
  //#pragma omp parallel for
  for(it = 0; it < rpp; ++it) {
    float x, y, dx, dy;
    for(y = -image_scale_y; y < image_scale_y; y += increment_y) {
      for(x = -image_scale_x; x < image_scale_x; x += increment_x) {
        // Noise is uniformly distributed -- i.e. it's not really noise
        float noise_x = it * increment_x / rpp;
        float noise_y = it * increment_y / rpp;
        dx = x + noise_x;
        dy = y + noise_y;
        
        count_included_bodies(root, accuracy, dx, dy);
        cells = (cell *)malloc(sizeof(cell) * count);
        count = 0;
        get_included_bodies(root, accuracy, dx, dy);
        
        deflect(&dx, &dy);
        // Source plan (where collected) is -source_scale/2 to source_scale/2
        if ((dx > -source_scale/2) && (dx < source_scale/2) &&
            (dy > -source_scale/2) && (dy < source_scale/2)) {
          // Work out the nearest pixel to put this in to
          // Add to remove the negative part of source_scale and then source_scale / pixels
          int px = (dx + source_scale/2) / (source_scale/pixel_x);
          int py = source_scale/ (source_scale/pixel_y) - (dy + source_scale/2) / (source_scale/pixel_y);
          results[py * pixel_x + px] += 1;
          if (results[py * pixel_x + px] > highest) highest = results[py * pixel_x + px];
        }
        count = 0;
        free(cells);
		cells = NULL;
      }
    }
     	fprintf(stderr, "\r%4d/%4d Complete\r", ++complete_iterations, rpp);
  }
  assert(highest > 0 && "No pixels were written on the output map");
  write_pgm(results, pixel_x, pixel_y, highest);
  
  // Free the memory allocated during processing
  free(lens_x);
  free(lens_y);
  free(lens_mass);
  free(results);
  free(curr);

  return 0;
}