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

             SUBROUTINE SETDEL

 SETDEL SETS THE INSIDE AND OUTSIDE LIMITS FOR DISTANCE FROM
 A STANDARD LEVEL WHICH AN OBSERVED MEASUREMENT MAY BE USED FOR
 INTERPOLATION.  INTERPOLATION IS DONE USING A MODIFIED REINIGER-
 ROSS SCHEME WHICH USES FOUR OBSERVATIONS SURROUNDING A STANDARD
 LEVEL.  HENCE, TWO DISTANCE LIMITS ARE USED, 
 ONE, THE MORE STRINGENT CRITERIA, IS FOR THE CLOSESTS DEEPER
 AND CLOSEST SHALLOWER MEASUREMENT WITH RESPECTS TO THE STANDARD
 LEVEL.  THE SECOND, LOOSER CRITERIA IS FOR THE FURTHEST SHALLOWER
 AND FURTHEST DEEPER MEASUREMENT.  THE CRITERIA ARE AS FOLLOWS:

   STANDARD LEVELS         INSIDE                OUTSIDE
     1-10                   50. M                 200. M
    11-13                  100. M                 200. M
    14-17                  100. M                 400. M
    18-21                  200. M                 400. M
    22-25                  200. M                1000. M
    26-40                 1000. M                1000. M

 SUBROUTINE STEPS:
  1. SET INSIDE LIMITS
  2. SET OUTSIDE LIMITS

**********************************************************************/
  
 
setdel_(

 int *nlevels,            /* NUMBER OF LEVELS */

 int *dz,                 /* STANDARD DEPTHS */

 float *del,              /* INSIDE DISTANCE LIMITS */

 float *del2              /* OUTSIDE DISTANCE LIMITS */

       )

{

  int j;         /* COUNTER */

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

  SET INSIDE LIMITS
 old way: by standard depth level

 for ( j=1; j<= 10; j++) *(del+j-1) = 50.;
 for ( j=11; j<= 17; j++) *(del+j-1) = 100.;
 for ( j=18; j<= 25; j++) *(del+j-1) = 200.;
 for ( j=26; j<= 40; j++) *(del+j-1) = 1000.;

new way: by depth

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

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

  SET OUTSIDE LIMITS
 old way: by standard depth level


 for ( j=1; j<= 13; j++) *(del2+j-1) = 200.;
 for ( j=14; j<= 21; j++)*(del2+j-1) = 400.;
 for ( j=22; j<= 40; j++)*(del2+j-1) = 1000.;

new way: by depth
*********************************************************/

 for ( j=0; j< *nlevels; j++ ) {

  if ( *(dz + j) <= 200. )
    *(del+j) = 50.; 
  else if ( *(dz + j) <= 800. )
    *(del+j) = 100.;
  else if ( *(dz + j) <= 1750. )
    *(del+j) = 200.;
  else
    *(del+j) = 1000.;

  if ( *(dz + j) <= 400. )
   *(del2+j) = 200.;
  else if ( *(dz + j) <= 1200. )
   *(del2+j) = 400.;
  else 
   *(del2+j) = 1000.;

 }

}