datareductionoperator.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 DATAREDUCTIONOPERATOR_H
#define DATAREDUCTIONOPERATOR_H
 
#include <vector>
 
#include <vlsv_writer.h>
 
#include "fsgrid.hpp"
#include "../definitions.h"
#include "../spatial_cells/spatial_cell_wrapper.hpp"
#include "../parameters.h"
#include "../grid.h"
#include "../sysboundary/ionosphere.h"
using namespace spatial_cell;
 
namespace DRO {

 
   class DataReductionOperator {
   public:
      DataReductionOperator();
      virtual ~DataReductionOperator();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const = 0;
      virtual bool getUnitMetadata(std::string& _unit,std::string& _unitLaTeX,std::string& _variableLaTeX,std::string& _unitConversion) {
   _unit=unit;
   _unitLaTeX=unitLaTeX;
   _unitConversion=unitConversion;
   _variableLaTeX=variableLaTeX;
   return true;
      };
      virtual bool setUnitMetadata(std::string& _unit,std::string& _unitLaTeX,std::string& _variableLaTeX,std::string& _unitConversion) {
   unit = _unit;
   unitLaTeX = _unitLaTeX;
   unitConversion = _unitConversion;
   variableLaTeX = _variableLaTeX;
   return true;
      }
 
      virtual std::string getName() const = 0;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool reduceDiagnostic(const SpatialCell* cell,Real * result);
      virtual bool setSpatialCell(const SpatialCell* cell) = 0;
 
   protected:
      std::string unit;
      std::string unitLaTeX;
      std::string variableLaTeX;
      std::string unitConversion;
 
   };
 
   class DataReductionOperatorHasParameters: public DataReductionOperator {
   public:
      DataReductionOperatorHasParameters() : DataReductionOperator() {};
      virtual bool writeParameters(vlsv::Writer& vlsvWriter) = 0;
   };
 
   class DataReductionOperatorFsGrid : public DataReductionOperator {
 
      public:
         typedef std::function<std::vector<double>(const FieldSolverData& fieldSolverData)> ReductionLambda;
 
      private:
         ReductionLambda lambda;
         std::string variableName;
 
      public:
         DataReductionOperatorFsGrid(const std::string& name, ReductionLambda l) : DataReductionOperator(),lambda(l),variableName(name) {};
         virtual std::string getName() const;
         virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
         virtual bool setSpatialCell(const SpatialCell* cell);
         virtual bool reduceData(const SpatialCell* cell,char* buffer);
         virtual bool reduceDiagnostic(const SpatialCell* cell,Real * result);
         virtual bool writeFsGridData(const FieldSolverData& fieldSolverData, const std::string& meshName,
                                      vlsv::Writer& vlsvWriter, const bool writeAsFloat = false);
   };
 
   // Generic (lambda-based) datareducer for ionosphere grid element-centered data
   class DataReductionOperatorIonosphereElement : public DataReductionOperator {
      public:
         typedef std::function<std::vector<Real>(SBC::SphericalTriGrid& grid)> ReductionLambda;
      private:
         ReductionLambda lambda;
         std::string variableName;
 
      public:
         DataReductionOperatorIonosphereElement(const std::string& name, ReductionLambda l): DataReductionOperator(), lambda(l),variableName(name) {};
         virtual std::string getName() const;
         virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
         virtual bool setSpatialCell(const SpatialCell* cell);
         virtual bool reduceData(const SpatialCell* cell,char* buffer);
         virtual bool reduceDiagnostic(const SpatialCell* cell,Real * result);
         virtual bool writeIonosphereData(SBC::SphericalTriGrid& grid, vlsv::Writer& vlsvWriter);
   };
 
   // Generic (lambda-based) datareducer for ionosphere grid node-centered data
   class DataReductionOperatorIonosphereNode : public DataReductionOperator {
      public:
         typedef std::function<std::vector<Real>(SBC::SphericalTriGrid& grid)> ReductionLambda;
      private:
         ReductionLambda lambda;
         std::string variableName;
 
      public:
         DataReductionOperatorIonosphereNode(const std::string& name, ReductionLambda l): DataReductionOperator(), lambda(l),variableName(name) {};
         virtual std::string getName() const;
         virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
         virtual bool setSpatialCell(const SpatialCell* cell);
         virtual bool reduceData(const SpatialCell* cell,char* buffer);
         virtual bool reduceDiagnostic(const SpatialCell* cell,Real * result);
         virtual bool writeIonosphereData(SBC::SphericalTriGrid& grid, vlsv::Writer& vlsvWriter);
   };
 
   // Generic (lambda-based) datareducer for ionosphere grid node-centered int data
   class DataReductionOperatorIonosphereNodeInt : public DataReductionOperator {
   public:
      typedef std::function<std::vector<int>(SBC::SphericalTriGrid& grid)> ReductionLambda;
   private:
      ReductionLambda lambda;
      std::string variableName;
 
   public:
      DataReductionOperatorIonosphereNodeInt(const std::string& name, ReductionLambda l): DataReductionOperator(), lambda(l),variableName(name) {};
      virtual std::string getName() const;
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual bool setSpatialCell(const SpatialCell* cell);
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool reduceDiagnostic(const SpatialCell* cell,Real * result);
      virtual bool writeIonosphereData(SBC::SphericalTriGrid& grid, vlsv::Writer& vlsvWriter);
   };
 
   // Generic (lambda-based) datareducer for vlasov grid data
   class DataReductionOperatorMPIGridCell : public DataReductionOperator{
      public:
         typedef std::function<std::vector<Real>(const SpatialCell* cell)> ReductionLambda;
      private:
         ReductionLambda lambda;
         int numFloats;
         std::string variableName;
 
      public:
         DataReductionOperatorMPIGridCell(const std::string& name, int numFloats, ReductionLambda l): DataReductionOperator(),lambda(l),numFloats(numFloats),variableName(name) {};
         virtual std::string getName() const;
         virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
         virtual bool setSpatialCell(const SpatialCell* cell) {return true;};
         virtual bool reduceData(const SpatialCell* cell,char* buffer);
         virtual bool reduceDiagnostic(const SpatialCell* cell,Real * result) {return false;};
   };
 
   class DataReductionOperatorCellParams: public DataReductionOperator {
   public:
      DataReductionOperatorCellParams(const std::string& name,const unsigned int parameterIndex,const unsigned int vectorSize);
      virtual ~DataReductionOperatorCellParams();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool reduceDiagnostic(const SpatialCell* cell,Real * result);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      uint _parameterIndex;
      uint vectorSize;
      std::string variableName;
      const Real *data;
   };
 
   class DataReductionOperatorDerivatives: public DataReductionOperatorCellParams {
   public:
      DataReductionOperatorDerivatives(const std::string& name,const unsigned int parameterIndex,const unsigned int vectorSize);
      virtual bool setSpatialCell(const SpatialCell* cell);
   };
 
   class DataReductionOperatorBVOLDerivatives: public DataReductionOperatorCellParams {
   public:
      DataReductionOperatorBVOLDerivatives(const std::string& name,const unsigned int parameterIndex,const unsigned int vectorSize);
      virtual bool setSpatialCell(const SpatialCell* cell);
   };
 
   class MPIrank: public DataReductionOperator {
   public:
      MPIrank();
      virtual ~MPIrank();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real rank;
      int mpiRank;
   };
 
   class MLPepochs: public DataReductionOperator {
   public:
      MLPepochs(cuint popID);
      virtual ~MLPepochs();
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
      virtual bool reduceDiagnostic(const SpatialCell* cell,Real* buffer);
 
   protected:
      uint32_t epochs;
      uint popID;
      std::string popName;
   };
 
   class MLPerror: public DataReductionOperator {
   public:
      MLPerror(cuint popID);
      virtual ~MLPerror();
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
      virtual bool reduceDiagnostic(const SpatialCell* cell,Real* buffer);
 
   protected:
      float error;
      uint popID;
      std::string popName;
   };
 
 
   class BoundaryType: public DataReductionOperator {
   public:
      BoundaryType();
      virtual ~BoundaryType();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      int boundaryType;
   };
 
   class BoundaryLayer: public DataReductionOperator {
   public:
      BoundaryLayer();
      virtual ~BoundaryLayer();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      int boundaryLayer;
   };
 
   class Blocks: public DataReductionOperator {
   public:
      Blocks(cuint popID);
      virtual ~Blocks();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool reduceDiagnostic(const SpatialCell* cell,Real* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      uint nBlocks;
      uint popID;
      std::string popName;
   };
 
   class VariableBVol: public DataReductionOperator {
   public:
      VariableBVol();
      virtual ~VariableBVol();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real B[3];
   };
 
 
   class VariablePressureSolver: public DataReductionOperator {
   public:
      VariablePressureSolver();
      virtual ~VariablePressureSolver();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real Pressure;
   };
 
   class VariablePTensorDiagonal: public DataReductionOperator {
   public:
      VariablePTensorDiagonal(cuint popID);
      virtual ~VariablePTensorDiagonal();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real averageVX, averageVY, averageVZ;
      Real PTensor[3];
      uint popID;
      std::string popName;
   };
 
   class VariablePTensorOffDiagonal: public DataReductionOperator {
   public:
      VariablePTensorOffDiagonal(cuint popID);
      virtual ~VariablePTensorOffDiagonal();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real averageVX, averageVY, averageVZ;
      Real PTensor[3];
      uint popID;
      std::string popName;
   };
 
   class DiagnosticFluxB: public DataReductionOperator {
   public:
      DiagnosticFluxB();
      virtual  ~DiagnosticFluxB();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceDiagnostic(const SpatialCell* cell,Real* result);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
 
   };
 
   class DiagnosticFluxE: public DataReductionOperator {
   public:
      DiagnosticFluxE();
      virtual  ~DiagnosticFluxE();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceDiagnostic(const SpatialCell* cell,Real* result);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
 
   };
 
   class VariableRhoThermal: public DataReductionOperator {
   public:
      VariableRhoThermal(cuint popID);
      virtual ~VariableRhoThermal();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real RhoThermal;
      uint popID;
      std::string popName;
      bool doSkip;
   };
 
   class VariableRhoNonthermal: public DataReductionOperator {
   public:
      VariableRhoNonthermal(cuint popID);
      virtual ~VariableRhoNonthermal();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real RhoNonthermal;
      uint popID;
      std::string popName;
      bool doSkip;
   };
 
   class VariableVThermal: public DataReductionOperator {
   public:
      VariableVThermal(cuint popID);
      virtual ~VariableVThermal();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real VThermal[3];
      uint popID;
      std::string popName;
      bool doSkip;
   };
 
   class VariableVNonthermal: public DataReductionOperator {
   public:
      VariableVNonthermal(cuint popID);
      virtual ~VariableVNonthermal();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real VNonthermal[3];
      uint popID;
      std::string popName;
      bool doSkip;
   };
 
   class VariablePTensorThermalDiagonal: public DataReductionOperator {
   public:
      VariablePTensorThermalDiagonal(cuint popID);
      virtual ~VariablePTensorThermalDiagonal();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real averageVX, averageVY, averageVZ;
      Real PTensor[3];
      uint popID;
      std::string popName;
      bool doSkip;
   };
 
   class VariablePTensorNonthermalDiagonal: public DataReductionOperator {
   public:
      VariablePTensorNonthermalDiagonal(cuint popID);
      virtual ~VariablePTensorNonthermalDiagonal();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real averageVX, averageVY, averageVZ;
      Real PTensor[3];
      uint popID;
      std::string popName;
      bool doSkip;
   };
 
   class VariablePTensorThermalOffDiagonal: public DataReductionOperator {
   public:
      VariablePTensorThermalOffDiagonal(cuint popID);
      virtual ~VariablePTensorThermalOffDiagonal();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real averageVX, averageVY, averageVZ;
      Real PTensor[3];
      uint popID;
      std::string popName;
      bool doSkip;
   };
 
   class VariablePTensorNonthermalOffDiagonal: public DataReductionOperator {
   public:
      VariablePTensorNonthermalOffDiagonal(cuint popID);
      virtual ~VariablePTensorNonthermalOffDiagonal();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real averageVX, averageVY, averageVZ;
      Real PTensor[3];
      uint popID;
      std::string popName;
      bool doSkip;
   };
 
   class VariableEffectiveSparsityThreshold: public DataReductionOperator {
   public:
      VariableEffectiveSparsityThreshold(cuint popID);
      virtual ~VariableEffectiveSparsityThreshold();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool reduceDiagnostic(const spatial_cell::SpatialCell* cell,Real* result);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      uint popID;
      std::string popName;
   };
 
   class VariableEnergyDensity: public DataReductionOperatorHasParameters {
   public:
      VariableEnergyDensity(cuint popID);
      virtual ~VariableEnergyDensity();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
      virtual bool writeParameters(vlsv::Writer& vlsvWriter);
 
   protected:
      uint popID;
      std::string popName;
      Real EDensity[3];
      Real solarwindenergy;
      Real E1limit;
      Real E2limit;
   };
 
   // Precipitation directional differential number flux (within loss cone)
   class VariablePrecipitationDiffFlux: public DataReductionOperatorHasParameters {
   public:
      VariablePrecipitationDiffFlux(cuint popID);
      virtual ~VariablePrecipitationDiffFlux();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
      virtual bool writeParameters(vlsv::Writer& vlsvWriter);
 
   protected:
      uint popID;
      std::string popName;
      int nChannels;
      Real emin, emax;
      Real lossConeAngle;
      std::vector<Real> channels, dataDiffFlux;
   };
 
 
   // V-space flatten into 1D mu-distribution
   class VariableMuSpace: public DataReductionOperatorHasParameters {
   public:
      VariableMuSpace(cuint popID);
      virtual ~VariableMuSpace();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
      virtual bool writeParameters(vlsv::Writer& vlsvWriter);
 
   protected:
      uint popID;
      std::string popName;
      int nBins;
   };
 
   // Precipitation directional differential number flux (along line)
   class VariablePrecipitationLineDiffFlux: public DataReductionOperatorHasParameters {
   public:
      VariablePrecipitationLineDiffFlux(cuint popID);
      virtual ~VariablePrecipitationLineDiffFlux();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
      virtual bool writeParameters(vlsv::Writer& vlsvWriter);
   protected:
      uint popID;
      std::string popName;
      int nChannels;
      Real emin, emax;
      std::vector<Real> channels, dataLineDiffFlux;
   };
 
   // Heat flux vector
   class VariableHeatFluxVector: public DataReductionOperator {
   public:
      VariableHeatFluxVector(cuint popID);
      virtual ~VariableHeatFluxVector();
 
      virtual bool getDataVectorInfo(std::string& dataType,unsigned int& dataSize,unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell,char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real averageVX, averageVY, averageVZ;
      Real HeatFlux[3];
      uint popID;
      std::string popName;
   };
 
   // Dimensionless non-maxwellianity parameter
   class VariableNonMaxwellianity : public DataReductionOperator {
   public:
      VariableNonMaxwellianity(cuint popID);
      virtual ~VariableNonMaxwellianity();
 
      virtual bool getDataVectorInfo(std::string& dataType, unsigned int& dataSize, unsigned int& vectorSize) const;
      virtual std::string getName() const;
      virtual bool reduceData(const SpatialCell* cell, char* buffer);
      virtual bool setSpatialCell(const SpatialCell* cell);
 
   protected:
      Real rho;
      Real V0[3];
      Real b_par[3];
      Real b_perp1[3];
      Real b_perp2[3];
      Real T_par;
      Real T_perp;
      Real epsilon;
      uint popID;
      std::string popName;
   };
 
} // namespace DRO
 
#endif