Ejemplo n.º 1
0
particle *MakeParticle(particle *P, REAL ENE, REAL ANG, REAL AZI, unsigned int *seed) {
    REAL	angle, azimuth;
    P->type = PROTON;
    P->energy = ENE;
    angle = ANG * M_PI / AS_REAL(180.0);
    azimuth = AZI * M_PI / AS_REAL(180.0);
    position_particle(azimuth, angle, P);
#if DO_ELASTIC
    GenerateElasticDistances(P, seed);
#endif
#if MIN_TRACE
    P->eloss = AS_REAL(0.0);
    P->where = WhereAmI(P->pos[CX], P->pos[CY], P->pos[CZ]);
#endif
#if GOM_DEBUG
    if (VERBOSE) {
	print_particle("Made particle:", P);
    }
#endif
    return(P);
}
Ejemplo n.º 2
0
void *blas_memory_alloc(int procpos){
  
  int position;
#if defined(WHEREAMI) && !defined(USE_OPENMP)
  int mypos;
#endif

  void *map_address;

  void *(*memoryalloc[])(void *address) = {
#ifdef ALLOC_DEVICEDRIVER
    alloc_devicedirver,
#endif
#if defined OS_LINUX  || defined OS_AIX  || defined __sun__  || defined OS_WINDOWS
    alloc_hugetlb,
#endif
#ifdef ALLOC_SHM
    alloc_shm,
#endif
#ifdef ALLOC_MMAP
    alloc_mmap,
#endif
#ifdef ALLOC_QALLOC
    alloc_qalloc,
#endif
#ifdef ALLOC_WINDOWS
    alloc_windows,
#endif
#ifdef ALLOC_MALLOC
    alloc_malloc,
#endif
    NULL,
  };
  void *(**func)(void *address);

  if (!memory_initialized) {
    
    LOCK_COMMAND(&alloc_lock);
    
    if (!memory_initialized) {
      
#if defined(WHEREAMI) && !defined(USE_OPENMP)
      for (position = 0; position < NUM_BUFFERS; position ++){
	memory[position].addr   = (void *)0;
	memory[position].pos    = -1;
	memory[position].used   = 0;
	memory[position].lock   = 0;
      }
#endif
      
#ifdef DYNAMIC_ARCH
      gotoblas_dynamic_init();
#endif

#if defined(SMP) && defined(OS_LINUX) && !defined(NO_AFFINITY)
      gotoblas_affinity_init();
#endif
      
#ifdef SMP
      if (!blas_num_threads) blas_cpu_number = blas_get_cpu_number();
#endif
      
#if defined(ARCH_X86) || defined(ARCH_X86_64) || defined(ARCH_IA64) || defined(ARCH_MIPS64)
#ifndef DYNAMIC_ARCH
      blas_set_parameter();
#endif
#endif

      memory_initialized = 1;
    }

    UNLOCK_COMMAND(&alloc_lock);
  }

#ifdef DEBUG
  printf("Alloc Start ...\n");
#endif

#if defined(WHEREAMI) && !defined(USE_OPENMP)

  mypos = WhereAmI();

  position = mypos;
  while (position > NUM_BUFFERS) position >>= 1;

  do {
    if (!memory[position].used && (memory[position].pos == mypos)) {
      
      blas_lock(&memory[position].lock);
      
      if (!memory[position].used) goto allocation;
      
      blas_unlock(&memory[position].lock);
    }
    
    position ++;
    
  } while (position < NUM_BUFFERS);


#endif

  position = 0;

  do {
    if (!memory[position].used) {
      
      blas_lock(&memory[position].lock);

      if (!memory[position].used) goto allocation;
      
      blas_unlock(&memory[position].lock);
    }
    
    position ++;
    
  } while (position < NUM_BUFFERS);
  
  goto error;

  allocation :

#ifdef DEBUG
  printf("  Position -> %d\n", position);
#endif

  memory[position].used = 1;

  blas_unlock(&memory[position].lock);

  if (!memory[position].addr) {
    do {
#ifdef DEBUG
      printf("Allocation Start : %lx\n", base_address);
#endif

      map_address = (void *)-1;

      func = &memoryalloc[0];

      while ((func != NULL) && (map_address == (void *) -1)) {

	map_address = (*func)((void *)base_address);

#ifdef ALLOC_DEVICEDRIVER
	if ((*func ==  alloc_devicedirver) && (map_address == (void *)-1)) {
	    fprintf(stderr, "OpenBLAS Warning ... Physically contigous allocation was failed.\n");
	}
#endif

#ifdef ALLOC_HUGETLBFILE
	if ((*func == alloc_hugetlbfile) && (map_address == (void *)-1)) {
#ifndef OS_WINDOWS
	    fprintf(stderr, "OpenBLAS Warning ... HugeTLB(File) allocation was failed.\n");
#endif
	}
#endif

#if defined OS_LINUX  || defined OS_AIX  || defined __sun__  || defined OS_WINDOWS
	if ((*func == alloc_hugetlb) && (map_address != (void *)-1)) hugetlb_allocated = 1;
#endif

	func ++;
      }

#ifdef DEBUG
      printf("  Success -> %08lx\n", map_address);
#endif
      if (((BLASLONG) map_address) == -1) base_address = 0UL;

      if (base_address) base_address += BUFFER_SIZE + FIXED_PAGESIZE;

    } while ((BLASLONG)map_address == -1);

    memory[position].addr = map_address; 

#ifdef DEBUG
    printf("  Mapping Succeeded. %p(%d)\n", (void *)memory[position].addr, position);
#endif
  }
 
#if defined(WHEREAMI) && !defined(USE_OPENMP)

  if (memory[position].pos == -1) memory[position].pos = mypos;

#endif

#ifdef DYNAMIC_ARCH

  if (memory_initialized == 1) {
    
    LOCK_COMMAND(&alloc_lock);
    
    if (memory_initialized == 1) {
      
      if (!gotoblas) gotoblas_dynamic_init();
      
      memory_initialized = 2;
    }
    
    UNLOCK_COMMAND(&alloc_lock);
    
  }
#endif


#ifdef DEBUG
  printf("Mapped   : %p  %3d\n\n",
	  (void *)memory[position].addr, position);
#endif  
  
  return (void *)memory[position].addr;

 error:
  printf("BLAS : Program is Terminated. Because you tried to allocate too many memory regions.\n");

  return NULL;
}
Ejemplo n.º 3
0
void Disperse2()
{
  double xmin, xmax, ymin, ymax, zmin, zmax, x, y, z, u, v, w;
  long uni0, cell0, root, cell, id, n;
  unsigned long seed;
  char uname[MAX_STR], cname[MAX_STR];

  /***************************************************************************/

  /***** Prompt input data ***************************************************/
  return;
  /* Get universe */
  
  fprintf(out, "Enter universe:\n");
    
  if (scanf("%s", uname) == EOF)
    Die(FUNCTION_NAME, "fscanf error");

  /* Get cell */
  
  fprintf(out, "Enter cell:\n");
    
  if (scanf("%s", cname) == EOF)
    Die(FUNCTION_NAME, "fscanf error");

  /***************************************************************************/

  /***** Find cell and universe pointers *************************************/

  /* Loop over universes */

  uni0 = (long)RDB[DATA_PTR_U0];
  while (uni0 > VALID_PTR)
    {
      /* Compare name */

      if (!strcmp(GetText(uni0 + UNIVERSE_PTR_NAME), uname))
	break;

      /* Next */

      uni0 = NextItem(uni0);
    }

  /* Check pointer */

  if (uni0 < VALID_PTR)
    Error(0, "Universe %s not found in geometry", uname);

  /* Loop over cells */

  cell0 = (long)RDB[DATA_PTR_C0];
  while (cell0 > VALID_PTR)
    {
      /* Compare name */

      if (!strcmp(GetText(cell0 + CELL_PTR_NAME), cname))
	break;

      /* Next */

      cell0 = NextItem(cell0);
    }

  /* Check pointer */

  if (cell0 < VALID_PTR)
    Error(0, "Cell %s not found in geometry", cname);

  /* Set thread id */

  id = 0;

  /* Init random number sequence */
      
  seed = ReInitRNG(1);
  SEED[0] = seed;

  /* Set plotter mode to avoid termination in geometry error, and quick */
  /* plotter mode to disable overlap check */

  WDB[DATA_PLOTTER_MODE] = (double)YES;
  WDB[DATA_QUICK_PLOT_MODE] = (double)YES;

  /* Override root universe pointer */

  root = (long)RDB[DATA_PTR_ROOT_UNIVERSE];
  WDB[DATA_PTR_ROOT_UNIVERSE] = (double)uni0;

  /***************************************************************************/

  /***** Sample code *********************************************************/

  /* Check pointers */

  CheckPointer(FUNCTION_NAME, "(uni0)", DATA_ARRAY, uni0);
  CheckPointer(FUNCTION_NAME, "(cell0)", DATA_ARRAY, cell0);

  /* Get universe boundaries */

  xmin = RDB[uni0 + UNIVERSE_MINX];
  xmax = RDB[uni0 + UNIVERSE_MAXX];
  ymin = RDB[uni0 + UNIVERSE_MINY];
  ymax = RDB[uni0 + UNIVERSE_MAXY];
  zmin = RDB[uni0 + UNIVERSE_MINZ];
  zmax = RDB[uni0 + UNIVERSE_MAXZ];
  
  fprintf(out, "\nboundaries : \nx = [%E,%E] \ny = [%E %E] \nz = [%E %E]\n\n",
	  xmin, xmax, ymin, ymax, zmin, zmax);

  /* Set direction vector (needed but not used) */

  u = 1.0;
  v = 0.0;
  w = 0.0;

  /* Sample 1000 random points and print coordinates that are inside the */
  /* universe and cell */

  for (n = 0; n < 1000; n++)
    {
      /* Sample random point */

      x = RandF(id)*(xmax - xmin) + xmin;
      y = RandF(id)*(ymax - ymin) + ymin;
      z = RandF(id)*(zmax - zmin) + zmin;

      /* Get cell pointer at position */

      cell = WhereAmI(x, y, z, u, v, w, id);

      /* Check pointer and print coordinates */

      if (cell == cell0)
	fprintf(out, "%E %E %E\n", x, y, z);
    }

  /***************************************************************************/

  /* Reset plotter mode */

  WDB[DATA_PLOTTER_MODE] = (double)YES;

  /* Put root universe pointer */

  WDB[DATA_PTR_ROOT_UNIVERSE] = (double)root;

  /* Terminate calculation */

  exit(0);
}
Ejemplo n.º 4
0
long MoveDT(long part, double majorant, double minxs, long *cell, double *xs0, 
	    double *x, double *y, double *z, double *l0, double *u, double *v, 
	    double *w, double E, long id)
{
  long ptr, type, mat, mat0, bc;
  double totxs, l, wgt;

  /* Check particle pointer */

  CheckPointer(FUNCTION_NAME, "(part)", DATA_ARRAY, part);

  /* Check coordinates and direction cosines */

  CheckValue(FUNCTION_NAME, "x", "", *x, -INFTY, INFTY);
  CheckValue(FUNCTION_NAME, "y", "", *y, -INFTY, INFTY);
  CheckValue(FUNCTION_NAME, "z", "", *z, -INFTY, INFTY);
  CheckValue(FUNCTION_NAME, "u", "", *u, -1.0, 1.0);
  CheckValue(FUNCTION_NAME, "v", "", *v, -1.0, 1.0);
  CheckValue(FUNCTION_NAME, "w", "", *w, -1.0, 1.0);

  /* Get particle type */

  type = (long)RDB[part + PARTICLE_TYPE];  

  /* Add to DT fraction counter */
		
  ptr = (long)RDB[RES_DT_TRACK_FRAC];
  CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr);
  AddBuf1D(1.0, 1.0, ptr, id, 2 - type);
  
  /* Check cross section and sample path length */
  
  CheckValue(FUNCTION_NAME, "majorant", "", majorant, ZERO, INFTY);
  l = -log(RandF(id))/majorant;

  /* Move particle to collision site */
		  
  *x = *x + *u*l;
  *y = *y + *v*l;
  *z = *z + *w*l;

  /* Set path length */
      
  *l0 = l;

  /* Reset previous material pointer and total xs */

  mat0 = -1;
  totxs = 0.0;

  /* Find location */

  *cell = WhereAmI(*x, *y, *z, *u, *v, *w, id);
  CheckPointer(FUNCTION_NAME, "(cell)", DATA_ARRAY, *cell);

  /* Check if point is outside the geometry */

  if ((long)RDB[*cell + CELL_TYPE] == CELL_TYPE_OUTSIDE)
    {
      /* Check if track is stopped at outer boundary */
		  
      if ((long)RDB[DATA_STOP_AT_BOUNDARY] == NO)
	{
	  /* Set weight to test that albedo boundary conditions were not */
	  /* applied */

	  wgt = 1.0;

	  /* Apply repeated boundary conditions */

	  bc = BoundaryConditions(cell, x, y, z, u, v, w, &wgt, id);

	  /* Check that condition was applied */
	  
	  if (bc != YES)
	    Die(FUNCTION_NAME, "Repeated bc not apllied");
 
	  /* Check change in weight */

	  if (wgt != 1.0)
	    Die(FUNCTION_NAME, "Change in weight (albedo)");

	  /* Find location */

	  *cell = WhereAmI(*x, *y, *z, *u, *v, *w, id);
	  CheckPointer(FUNCTION_NAME, "(cell)", DATA_ARRAY, *cell);
	}
      else 
	{
	  /* Stop track at boundary */

	  StopAtBoundary(cell, x, y, z, l0, *u, *v, *w, id);

	  /* Set cross section */

	  *xs0 = -1.0;

	  /* Check distance */

	  CheckValue(FUNCTION_NAME, "l0", "", *l0, ZERO, INFTY);

	  /* Return surface crossing */
      
	  return TRACK_END_SURF;
	}
    }

  /* Get material pointer */

  mat = (long)RDB[*cell + CELL_PTR_MAT];
  mat = MatPtr(mat, id);
  
  /* Check pointer */
  
  if (mat != mat0)
    {
      /* Get total cross section */
      
      totxs = TotXS(mat, type, E, id);
      
      /* Remember material */
      
      mat0 = mat;
    }
  
  /* Check total xs */
  
  CheckValue(FUNCTION_NAME, "totxs", "", totxs, 0.0, INFTY);
  
  /* Compare to minimum value */
  
  if (totxs > minxs)
    {
      /* Sample between real and virtual collision */
      
      if (RandF(id) < totxs/majorant)
	{
	  /* Set cross section */
	  
	  *xs0 = totxs;
	  
	  /* Add to success counter */
	  
	  ptr = (long)RDB[RES_DT_TRACK_EFF];
	  CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY,ptr);
	  AddBuf1D(1.0, 1.0, ptr, id, 2 - type);
	  
	  /* Check distance */

	  CheckValue(FUNCTION_NAME, "l0", "", *l0, ZERO, INFTY);

	  /* Return collision */
	  
	  return TRACK_END_COLL;
	}
      else
	{
	  /* Set cross section */
	  
	  *xs0 = -1.0;
	  
	  /* Add to failure counter */
	  
	  ptr = (long)RDB[RES_DT_TRACK_EFF];
	  CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY,ptr);
	  AddBuf1D(1.0, 1.0, ptr, id, 4 - type);
	  
	  /* Check distance */

	  CheckValue(FUNCTION_NAME, "l0", "", *l0, ZERO, INFTY);

	  /* Return virtual */
	  
	  return TRACK_END_VIRT;
	}
    }
  else
    {
      /* Sample scoring */
      
      if (RandF(id) < minxs/majorant)
	{
	  /* Set cross section */
	  
	  *xs0 = minxs;
	  
	  /* Sample between real and virtual collision */
	  
	  if (RandF(id) < totxs/minxs)
	    {
	      /* Add to success counter */
	      
	      ptr = (long)RDB[RES_DT_TRACK_EFF];
	      CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY,ptr);
	      AddBuf1D(1.0, 1.0, ptr, id, 2 - type);
	      
	      /* Check distance */

	      CheckValue(FUNCTION_NAME, "l0", "", *l0, ZERO, INFTY);

	      /* Return collision */
	      
	      return TRACK_END_COLL;
	    }
	  else
	    {
	      /* Add to failure counter */
	      
	      ptr = (long)RDB[RES_DT_TRACK_EFF];
	      CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY,ptr);
	      AddBuf1D(1.0, 1.0, ptr, id, 4 - type);
	      
	      /* Check distance */

	      CheckValue(FUNCTION_NAME, "l0", "", *l0, ZERO, INFTY);
	  
	      /* Return virtual */
	      
	      return TRACK_END_VIRT;
	    }
	}
      else
	{
	  /* Set cross section */
	  
	  *xs0 = -1.0;
	  
	  /* Add to failure counter */
	  
	  ptr = (long)RDB[RES_DT_TRACK_EFF];
	  CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY,ptr);
	  AddBuf1D(1.0, 1.0, ptr, id, 4 - type);
	  
	  /* Check distance */

	  CheckValue(FUNCTION_NAME, "l0", "", *l0, ZERO, INFTY);

	  /* Return virtual */
	  
	  return TRACK_END_VIRT;
	}
    }
}
Ejemplo n.º 5
0
// Remember that this function is called at 2hz
static int OnTimerNotify(WindowControl *Sender)
{
  static short rezoom=0;
  static short limiter=0; // safe limiter
  #define ORCREZOOM 2

  // We wait for some time before forcing nearest search, because we need to be sure
  // that the visibility scan is updated
  if (--WaitToCallForce>0) {
	if (WaitToCallForce==1) {
		#ifdef DEBUG_ORTIMER
		StartupStore(_T("..... Force Calculation\n"));
		#endif
		MapWindow::RefreshMap(); // trigger rescan or we shall wait for 2 seconds more!
		LKSW_ForceNearestTopologyCalculation=true;
		// set wait times for zoom effective in the background and return
		rezoom=ORCREZOOM; 
		limiter=0;
	}
	#ifdef DEBUG_ORTIMER
	else {
		StartupStore(_T("..... WaitToCallForce\n"));
	}
	#endif
	return 0;
  }

  // If the Nearest topology calculation is still running we wait
  if (LKSW_ForceNearestTopologyCalculation) {
	if (++limiter > 20) {
		// Something is wrong, lets get out of here because there is no exit button!
		StartupStore(_T("...... Oracle ForceNearestTopo limit exceeded, aborting search%s"),NEWLINE);
		LKSW_ForceNearestTopologyCalculation=false; // time exceeded, reset forced
		limiter=0;
		rezoom=0;
		goto _end;
	}
	#ifdef DEBUG_ORTIMER
	StartupStore(_T("..... Wait for ForceNearest done\n"));
	#endif
	return 0;
  }

  limiter=0; // probably useless

  // Ok the ForceNearestTopo was cleared by Terrain search, so we have the nearesttopo items ready.
  // Do we need still to rezoom for letting whereami search for nearest waypoints in a visibility
  // screen range?
  if (rezoom>0) {
	// Extend a wide search of farvisible items 
	// We do it now that nearestTopology has been calculated,
	// because WhereAmI will issue some Nearest search on waypoints
	// and we need to include airports a bit more far away
	if (rezoom==ORCREZOOM) {
		#ifdef DEBUG_ORTIMER
		StartupStore(_T("..... REZOOM\n"));
		#endif
		MapWindow::zoom.EventSetZoom(6);
		MapWindow::ForceVisibilityScan=true;
		MapWindow::RefreshMap();
	} 
	#ifdef DEBUG_ORTIMER
	else StartupStore(_T("..... WAIT AFTER REZOOM\n"));
	#endif
	// rezoom once, then wait
	rezoom--;
	return 0;
  }

_end:
  #ifdef DEBUG_ORTIMER
  StartupStore(_T("..... LETS GO\n"));
  #endif
  // Dont come back here anymore!
  wf->SetTimerNotify(NULL);

  // Bell, and print results
  if (EnableSoundModes) LKSound(TEXT("LK_GREEN.WAV"));
  WhereAmI();

  // Remember to force exit from showmodal, because there is no Close button
  wf->SetModalResult(mrOK);
  return 0;
}