/*=========================================================================
                                                                                
Copyright (c) 2007, Los Alamos National Security, LLC

All rights reserved.

Copyright 2007. Los Alamos National Security, LLC. 
This software was produced under U.S. Government contract DE-AC52-06NA25396 
for Los Alamos National Laboratory (LANL), which is operated by 
Los Alamos National Security, LLC for the U.S. Department of Energy. 
The U.S. Government has rights to use, reproduce, and distribute this software. 
NEITHER THE GOVERNMENT NOR LOS ALAMOS NATIONAL SECURITY, LLC MAKES ANY WARRANTY,
EXPRESS OR IMPLIED, OR ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE.  
If software is modified to produce derivative works, such modified software 
should be clearly marked, so as not to confuse it with the version available 
from LANL.
 
Additionally, redistribution and use in source and binary forms, with or 
without modification, are permitted provided that the following conditions 
are met:
-   Redistributions of source code must retain the above copyright notice, 
    this list of conditions and the following disclaimer. 
-   Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution. 
-   Neither the name of Los Alamos National Security, LLC, Los Alamos National
    Laboratory, LANL, the U.S. Government, nor the names of its contributors
    may be used to endorse or promote products derived from this software 
    without specific prior written permission. 

THIS SOFTWARE IS PROVIDED BY LOS ALAMOS NATIONAL SECURITY, LLC AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
ARE DISCLAIMED. IN NO EVENT SHALL LOS ALAMOS NATIONAL SECURITY, LLC OR 
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
                                                                                
=========================================================================*/

#ifndef BasicDefinition_h
#define BasicDefinition_h

#ifdef USE_VTK_COSMO
#include "vtkType.h"
#else
#include <stdint.h>
#endif

///////////////////////////////////////////////////////////////////////////
//

#ifdef USE_VTK_COSMO
#ifdef ID_64
   typedef      vtkTypeInt64 ID_T;           // Particle and halo ids
#else
   typedef      vtkTypeInt32 ID_T;           // Particle and halo ids
#endif
#else
#ifdef ID_64
   typedef      int64_t ID_T;           // Particle and halo ids
#else
   typedef      int32_t ID_T;           // Particle and halo ids
#endif
#endif

#ifdef POSVEL_64
   typedef      double  POSVEL_T;       // Position,velocity
   typedef      double  POTENTIAL_T;    // Potential
#else
   typedef      float   POSVEL_T;       // Position,velocity
   typedef      float   POTENTIAL_T;    // Potential
#endif

#ifdef GRID_64
   typedef      double  GRID_T;         // Grid types
#else
   typedef      float   GRID_T;         // Grid types
#endif

#ifdef USE_VTK_COSMO
typedef vtkTypeInt32    STATUS_T; // Dead (which neighbor) or alive particles
typedef vtkTypeUInt16   MASK_T;   // Other particle information
#else
typedef int32_t         STATUS_T; // Dead (which neighbor) or alive particles
typedef uint16_t        MASK_T;   // Other particle information
#endif

///////////////////////////////////////////////////////////////////////////

const float MAX_FLOAT   = 1.0e15;
const float MIN_FLOAT   = -1.0e15;

const int   RECORD      = 0;    // Input data is by particle record
const int   BLOCK       = 1;    // Input data is blocked by variable

const int   DIMENSION   = 3;
const int   BUF_SZ      = 512;  // Character buffer

// Constants for Spherical Over Dense calculation
const double CHAIN_SIZE         = 2.0;           // Size for bucket mesh
const double RHO_C              = 2.77536627e11; // Critical density
                                                 // in (M_sun/h) / (Mpc/h)^3
const double RHO_RATIO          = 200.0;         // density/critical density
const double SOD_MASS           = 1.0e14;        // for initial SOD radius
                                                 // in (M_sun/h)
const double MIN_RADIUS_FACTOR  = 0.5;           // Factor of initial SOD radius
const double MAX_RADIUS_FACTOR  = 2.0;           // Factor of initial SOD radius
const int    MIN_SOD_SIZE       = 1000;          // Min FOF halo for SOD
const float  MIN_SOD_MASS       = 5.0e12;        // Min FOF mass for SOD
const int    NUM_SOD_BINS       = 20;            // Log bins for SOD halo

// Constants for subhalo finding
const int    NUM_CHILDREN	= 8;             // Barnes Hut octree
const double GRAVITY_C          = 43.015e-10;
                                // Gravitional constant for potential energy
const double ALPHA_SUBHALO	= 1.0;
                                // Controls cut/grow of subhalo
                                // 1.0 / alphaFactor is the number of times 
                                // larger a candidate must be in order for the 
                                // smaller to be cut rather than allowed to grow
                                // Set to 1.0 means always cut as in SUBFIND
                                // Set to 0.2 main halo always wins cut/grow
                                // Set to 0.01 small structures grow
const double BETA_SUBHALO	= 0.0;
                                // Controls the Poisson noise significance test
                                // If average density of particles in a group
                                // is greater than (1 + beta) * density of
                                // saddlepoint particle, group is considered
                                // significant and stands on its own
                                // Set to 0.0 means always significant
                                // Set to 0.25 helps small scale connectivity 

const int    NUM_SPH_DENSITY	= 64;
				// Number of neigbor particles used in
                                // calculating SPH smoothing length and density
const int    NUM_SUBHALO_NEIGHBOR = 20;
                                // Number of closest neighbors looked at
                                // in placing particle in a subgroup
const int    MIN_SUBHALO_SIZE	= 20;
                                // Smallest allowed subhalo
const int    MIN_FOF_SUBHALO	= 2000;
                                // Smallest FOF halo which will have
                                // subhalo finding run on it

// Constants for speeding up unbind calculation on very large subhalos
const int    MAX_UNBIND_1	= 100;
                                // When unbinding reaches less than this
                                // number of particles in subgroup remove
                                // only one particle before running unbind again
const int    MAX_UNBIND_2	= 2000;
                                // When unbinding reaches less than this
                                // number of particles in subgroup remove
                                // remove (1 / FACTOR_UNBIND_1) total positive
                                // energy particles before running unbind again
const int    MAX_UNBIND_3	= 40000;
                                // When unbinding reaches less than this
                                // number of particles in subgroup remove
                                // remove (1 / FACTOR_UNBIND_2) total positive
                                // energy particles before running unbind again
                                // Also maximum subhalo candidate for unbinding
                                // Used for development because that stage
                                // takes so long and normally this is only
                                // the main subhalo and all particles unbound
                                // would go to fuzz
const int    FACTOR_UNBIND_1	= 4;
				// Between MAX_UNBIND_1 and MAX_UNBIND_2
                                // remove 25% of the positive total energy
                                // particles
const int    FACTOR_UNBIND_2	= 2;
				// Betweend MAX_UNBIND_2 and MAX_UNBIND_3
                                // remove 50% of the positive total energy
                                // particles
const int    MAX_UNBIND_DELETE	= 20;
                                // To speed up unbinding when large candidate
                                // reaches this number of particles with
                                // positive total energy just quit
                                                 

// Cosmology record data in .cosmo format
const int   COSMO_FLOAT = 7;    // x,y,z location and velocity plus mass
const int   COSMO_INT   = 1;    // Particle id
const int   RECORD_SIZE = sizeof(POSVEL_T) * COSMO_FLOAT + 
                          sizeof(ID_T) * COSMO_INT;

const bool  ENFORCE_MAX_READ = false;
const int   MAX_READ    = 8000000;
                                // Maximum number of particles to read at a time
                                // Multipled by COSMO_FLOAT floats
                                // makes the largest MPI allowed buffer

const float DEAD_FACTOR = 1.20f; // Number of dead allocated is % more than max

const int   ALIVE       = -1;   // Particle belongs to this processor
const int   MIXED       = ALIVE - 1;
                                // For a trick to quickly know what
                                // particles should be output

const int   UNMARKED    = -1;   // Mixed halo needs MASTER to arbitrate
const int   INVALID     = 0;    // Mixed halo is not recorded on processor
const int   VALID       = 1;    // Mixed halo is recorded on processor

const int   MASTER      = 0;    // Processor to do merge step

const int   MERGE_COUNT = 20;   // Number of tags to merge on in mixed

// Parameters for center finding
const int   MBP_THRESHOLD = 5000; // Threshold between n^2 and AStar methods
const int   MCP_THRESHOLD = 8000;// Threshold between n^2 and Chain methods
const int   MCP_CHAIN_FACTOR = 5; // Subdivide bb for building chaining mesh

//
// Neighbors are enumerated so that particles can be attached to the correct
// neighbor, but these pairs must be preserved for the ParticleExchange.
// Every processor should be able to send and receive on every iteration of
// the exchange, so if everyone sends RIGHT and receives LEFT it works
//
// Do not change this pairing order.
//
enum NEIGHBOR
{
  X0,                   // Left face
  X1,                   // Right face

  Y0,                   // Bottom face
  Y1,                   // Top face

  Z0,                   // Front face
  Z1,                   // Back face

  X0_Y0,                // Left   bottom edge
  X1_Y1,                // Right  top    edge

  X0_Y1,                // Left   top    edge
  X1_Y0,                // Right  bottom edge

  Y0_Z0,                // Bottom front  edge
  Y1_Z1,                // Top    back   edge

  Y0_Z1,                // Bottom back   edge
  Y1_Z0,                // Top    front  edge

  Z0_X0,                // Front  left   edge
  Z1_X1,                // Back   right  edge

  Z0_X1,                // Front  right  edge
  Z1_X0,                // Back   left   edge

  X0_Y0_Z0,             // Left  bottom front corner
  X1_Y1_Z1,             // Right top    back  corner

  X0_Y0_Z1,             // Left  bottom back  corner
  X1_Y1_Z0,             // Right top    front corner

  X0_Y1_Z0,             // Left  top    front corner
  X1_Y0_Z1,             // Right bottom back  corner

  X0_Y1_Z1,             // Left  top    back  corner
  X1_Y0_Z0              // Right bottom front corner
};

const int NUM_OF_NEIGHBORS      = 26;

// Header for Gadget input files
const int GADGET_GAS            = 0;
const int GADGET_HALO           = 1;
const int GADGET_DISK           = 2;
const int GADGET_BULGE          = 3;
const int GADGET_STARS          = 4;
const int GADGET_BOUND          = 5;
const int NUM_GADGET_TYPES      = 6;    // Types of gadget particles

const int GADGET_HEADER_SIZE    = 256;  // Size when the endian matches
const int GADGET_HEADER_SIZE_SWP= 65536;// Size when the endian doesn't match
const int GADGET_FILL           = 60;   // Current fill to HEADER SIZE
const int GADGET_SKIP           = 4;    // Bytes the indicate block size
const int GADGET_2_SKIP         = 16;   // Extra bytes in gadget-2

const int GADGET_1              = 1;
const int GADGET_2              = 2;

struct GadgetHeader {
  int      npart[NUM_GADGET_TYPES];
  double   mass[NUM_GADGET_TYPES];
  double   time;
  double   redshift;
  int      flag_sfr;
  int      flag_feedback;
  int      npartTotal[NUM_GADGET_TYPES];
  int      flag_cooling;
  int      num_files;
  double   BoxSize;
  double   Omega0;
  double   OmegaLambda;
  double   HubbleParam;
  int      flag_stellarage;
  int      flag_metals;
  int      HighWord[NUM_GADGET_TYPES];
  int      flag_entropy;
  char     fill[GADGET_FILL];
};

#endif