parameters.h

Go to the documentation of this file.

/*
 * This file is part of Vlasiator.
 * Copyright 2010-2016 Finnish Meteorological Institute
 *
 * For details of usage, see the COPYING file and read the "Rules of the Road"
 * at http://www.physics.helsinki.fi/vlasiator/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef PARAMETERS_H
#define PARAMETERS_H
#include <limits>
#include <mpi.h>
#include <stdint.h>
#include <string>
#include <vector>
#include <map>
#include "fsgrid.hpp"
 
#include "definitions.h"
 
const uint64_t INVALID_CELLID = 0;
 
struct Parameters {
   static Real xmin;    
   static Real xmax;    
   static Real ymin;    
   static Real ymax;    
   static Real zmin;    
   static Real zmax;    
   static Real dx_ini;  
   static Real dy_ini;  
   static Real dz_ini;  
 
   static uint xcells_ini; 
   static uint ycells_ini; 
   static uint zcells_ini; 
 
   static Real t;     
   static Real t_min; 
   static Real t_max; 
   static Real dt;    
   static Real dt_ceil; 
 
   static Real vlasovSolverMaxCFL;   
   static Real vlasovSolverMinCFL;   
   static bool vlasovSolverGhostTranslate;   
   static uint vlasovSolverGhostTranslateExtent;   
   static Real fieldSolverMinCFL;    
   static Real fieldSolverMaxCFL;    
   static uint fieldSolverSubcycles; 
 
   static uint tstep_min; 
   static uint tstep_max; 
   static uint tstep;     
 
   static bool meshRepartitioned;         
   static std::vector<CellID> localCells; 
 
   static bool adaptGPUWID;         
   static uint GPUallocations;         
 
   static uint diagnosticInterval;
   static std::vector<std::string> systemWriteName;  
   static std::vector<std::string> systemWritePath;  
   static std::vector<Real> systemWriteTimeInterval; 
   static std::vector<int>
       systemWriteDistributionWriteStride; 
   static bool systemWriteDistributionCompressed; /*Will apply ASTERIX compression to VDFs in bulk files*/
   static bool systemWriteRestartCompressed;      /*Will apply ASTERIX compression to VDFs in restart files*/
   static bool systemWriteRecoveryCompressed;     /*Will apply ASTERIX compression to VDFs in recovery files*/
   static std::vector<int>
       systemWriteDistributionWriteXlineStride; 
   static std::vector<int>
       systemWriteDistributionWriteYlineStride; 
   static std::vector<int>
       systemWriteDistributionWriteZlineStride; 
   static std::vector<Real>
       systemWriteDistributionWriteShellRadius; 
   static std::vector<int>
       systemWriteDistributionWriteShellStride; 
   static std::vector<bool> systemWriteFsGrid; 
   static bool systemWriteAllDROs; 
   static bool diagnosticWriteAllDROs; 
   static std::vector<int> systemWrites;        
   static std::vector<std::pair<std::string, std::string>>
       systemWriteHints; 
   static std::vector<std::pair<std::string, std::string>>
       restartReadHints; 
   static std::vector<std::pair<std::string, std::string>>
       restartWriteHints; 
 
   static bool writeInitialState; 
   static bool writeFullBGB; 
   static Real saveRestartWalltimeInterval; 
   static uint saveRecoverTstepInterval;    
   static uint exitAfterRestarts;           
   static uint recoverMaxFiles;             /*<! Write cyclically this many recover files before overwriting older ones.*/
   static uint64_t vlsvBufferSize;          
   static int restartStripeFactor;          
   static int systemStripeFactor;             
   static std::string restartWritePath; 
   static std::string recoverWritePath; 
 
   static bool recalculateStencils; 
 
   static bool propagateField;              
   static bool propagateVlasovAcceleration; 
   static bool propagateVlasovTranslation;  
 
   static Real maxWaveVelocity;         
   static uint maxFieldSolverSubcycles; 
   static Real resistivity;             
   static uint ohmHallTerm; 
   static uint ohmGradPeTerm; 
   static Real electronTemperature; 
   static Real
       electronDensity; 
   static Real electronPTindex; 
 
   static bool fieldSolverDiffusiveEterms; 
   static bool fieldSolverFiniteDifferencingAtBoundaries; 
 
   static Real maxSlAccelerationRotation; 
   static int maxSlAccelerationSubcycles; 
   static bool vlasovAccelerateMaxwellianBoundaries; 
 
   static Real hallMinimumRhom; 
   static Real hallMinimumRhoq; 
 
   static std::string loadBalanceAlgorithm; 
   static std::map<std::string, std::string> loadBalanceOptions;  // Other Load balancing options
   static uint rebalanceInterval;           
   static bool prepareForRebalance; 
 
   static std::vector<std::string>
       outputVariableList; 
   static std::vector<std::string>
       diagnosticVariableList; 
 
   static std::string restartFileName; 
   static bool isRestart;              
   static int writeAsFloat;            
   static int
       writeRestartAsFloat;     
   static bool dynamicTimestep; 
 
   static std::string projectName; 
 
   static bool bailout_write_restart; 
   static Real bailout_min_dt;        
   static Real bailout_max_memory;    
   static uint bailout_velocity_space_wall_margin; 
 
   static int amrMaxSpatialRefLevel; 
   static int amrMaxAllowedSpatialRefLevel; 
   static bool adaptRefinement;
   static bool refineOnRestart;
   static bool forceRefinement;
   static bool shouldFilter;
   static bool useAlpha1;
   static Real alpha1RefineThreshold;
   static Real alpha1CoarsenThreshold;
   static bool useAlpha2;
   static Real alpha2RefineThreshold;
   static Real alpha2CoarsenThreshold;
   // TODO: consider renaming to alpha3 or something to that effect
   static bool useVorticity;
   static Real vorticityRefineThreshold;
   static Real vorticityCoarsenThreshold;
   static bool useAnisotropy;
   static Real anisotropyRefineThreshold;
   static Real anisotropyCoarsenThreshold;
   static int anisotropyMaxReflevel;
   static uint refineCadence;
   static Real refineAfter;
   static Real refineRadius;
   static Real alphaDRhoWeight;
   static Real alphaDUWeight;
   static Real alphaDPSqWeight;
   static Real alphaDBSqWeight;
   static Real alphaDBWeight;
   static int refineBoxNumber;
   static std::vector<Real> refinementMinX; 
   static std::vector<Real> refinementMinY; 
   static std::vector<Real> refinementMinZ; 
   static std::vector<Real> refinementMaxX; 
   static std::vector<Real> refinementMaxY; 
   static std::vector<Real> refinementMaxZ; 
   static int maxFilteringPasses;
   static int amrBoxNumber;
   static std::vector<uint> amrBoxHalfWidthX;
   static std::vector<uint> amrBoxHalfWidthY;
   static std::vector<uint> amrBoxHalfWidthZ;
   static std::vector<Realf> amrBoxCenterX;
   static std::vector<Realf> amrBoxCenterY;
   static std::vector<Realf> amrBoxCenterZ;
   static std::vector<int> amrBoxMaxLevel;
   static bool amrTransShortPencils;        
   static std::vector<std::string> blurPassString;
   static std::vector<int> numPasses;
   static bool artificialPADiff; // Artificial velocity space Diffusion
   static Realf PADcoefficient; // Artificial pitch-angle diffusion coefficient
   static Realf PADCFL; // Artificial pitch-angle diffusion CFL
   static int PADvbins; // Number of bins in velocity for pitch-angle diffusion
   static int PADmubins; // Number of bins in mu for pitch-angle diffusion
   static std::string PADnu0; // Path to txt file for nu0
   static Realf PADfudge; // Fudge factore for diffusion
 
   static std::array<fsgrid::Task_t,3> manualFsGridDecomposition;
   static std::array<fsgrid::Task_t,3> overrideReadFsGridDecomposition;
 
   //Asterix  VDF Compression
   enum ASTERIX_COMPRESSION_METHODS{
           NONE,
           ZFP,
           OCTREE,
           MLP,
           MLP_MULTI,
   };
   static std::string mlpLayer;
   static std::vector<std::size_t> mlp_arch; /* Hidden Layers in fMLP*/
   static std::size_t mlp_fourier_order;       /* Maximum fourier order in fMLP */
   static std::size_t mlp_max_epochs;
   static Real compression_interval;
   static Real mlp_tollerance;
   static std::size_t max_vdfs_per_nn;
   static Real octree_tolerance;
   static bool doCompress;
   static std::string method_str;
   static ASTERIX_COMPRESSION_METHODS vdf_compression_method;
 
   static bool computeCurvature; /*<! Boolean flag, if true the curvature of magnetic field is computed. */

   static bool addParameters();

   static void getParameters();
};
 
#endif