---

Parser.h

/****************************************************************************
 *                                                                          *
 *  Program: FDDlib                                                         *
 *  Version: 1.1                                                            *
 *                                                                          *
 *  Copyright (C) 2002 - 2004 by Eric Miller and Dana Brooks                *
 *  All rights reserved.                                                    *
 *                                                                          *
 *  This software is Version 1.1 of the fddlib tomography toolbox.          *
 *  It is not to be redistributed or used for any commercial purpose        *
 *  without the prior written consent of the authors and Northeastern       *
 *  University.                                                             *
 *                                                                          *
 *  This software is provided as is, and any express or implied warranties, *
 *  including but not limited to the implied warranty of merchantability    *
 *  and the implied warranty of fitness for a particular purpose, are dis-  *
 *  claimed.  In no event shall the authors or Northeastern University 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 busi-   *
 *  ness interruption) however caused and on any theory of liability,       *
 *  whether in contract, strict liability, or tort (including negligence or *
 *  otherwise) arising in any way from the use of this software, even if    *
 *  advised of the possibility of such damage.                              *
 *                                                                          *
 *  Portions of this code benefit from ideas from Kyle Guilbert, Greg       *
 *  Boverman, Derek Uluski, David Kaeli, and Jennifer Black                 *
 *                                                                          *
 ****************************************************************************/

#ifndef _PARSER_H_
#define _PARSER_H_

#include <vector>
#include <string>
#include <list>
#include <bitset>
#include <fstream>
#include "Complex.h"
#include "Property.h"
#include "grid_enums.h"
#include "solver.h"

namespace FDDparse
{

class Parser {

// public data
public:
 
  enum Dimension {D_2D, D_3D};

  enum BoundType {Dirichlet, Neumann, Mixed};

  enum PreconType {Diagonal, ILU0, SSOR};

  enum BackgroundType {Constant, Layered, Mapped, Arbitrary};

  enum GridType {Nebulous, ArbitraryCartesian, RegularCartesian};
  
  enum TagType {TAG_GRID, TAG_SOURCES, TAG_DETECTORS, TAG_PROPERTIES,
                TAG_MEDIUMSETUP, TAG_ANOMALIES, TAG_BOUNDARIES,
                TAG_OPTIONS, TAG_POINTLIST, TAG_DELTALIST, TAG_NONE };

  // ANOMALIES //

  struct s_sphericalanomaly
  {
    double xcenter;

    double ycenter;

    double zcenter;

    double radius;

    std::string prop;
  };

  struct s_cubicalanomaly
  {
    double xcenter;

    double ycenter;

    double zcenter;

    double length;

    std::string prop;
  };
  
  struct s_ellipsoidalanomaly
  {
    double xcenter;
    
    double ycenter;
    
    double zcenter;
    
    double xlen;
    
    double ylen;
    
    double zlen;
    
    double theta1;
    
    double theta2;
    
    double theta3;
    
    std::string prop;
  };
  
  struct s_circularanomaly
  {
    double xcenter;

    double ycenter;

    double radius;

    std::string prop;
  };

  struct s_squareanomaly
  {
    double xcenter;

    double ycenter;

    double length;

    std::string prop;
  };

  // SOURCES //

  struct s_arbitrarysource
  {
    int id;
    
    std::vector <double> x;

    std::vector <double> y;

    std::vector <double> z;

    std::vector <FDDlib::Complex <double> > val;

    std::vector<double> frequencies;
  };

  struct s_monopolesource
  {
    int id;
    
    double xloc;

    double yloc;

    double zloc;

    double magnitude;

    double phase;

    std::vector<double> frequencies;
  };

  struct s_dipolesource
  {
    int id;
        
    double x[2];

    double y[2];

    double z[2];

    double magnitude[2];

    double phase[2];

    std::vector<double> frequencies;
  };

  // DETECTORS //

  struct s_arbitrarydetector
  {
    int id;

    std::vector <double> x;

    std::vector <double> y;

    std::vector <double> z;

    std::vector < FDDlib::Complex <double> > weight;
  };

  struct s_monopoledetector
  {
    int id;
        
    double xloc;

    double yloc;

    double zloc;
  };

  struct s_dipoledetector
  {
    int id;

    double x[2];

    double y[2];

    double z[2];

    FDDlib::Complex<double> weight[2];
  };

  struct s_nebulousgrid
  {
    int numnodes;

    char * nodefile;

    double espeed;

  };

  struct s_regcartgrid
  {
    int xdim;

    int ydim;

    int zdim;

    double stepsize;

    double espeed;

  };

  struct s_arbcartgrid
  {
    int xdim;

    int ydim;

    int zdim;

    char * deltafile;

    double espeed;
    
    std::vector<double> deltax;

    std::vector<double> deltay;

    std::vector<double> deltaz;

  };

  struct s_node
  {
    int id;

    double xloc;

    double yloc;

    double zloc;

    std::vector <int> neighbors;

    std::string property;

    BoundType bcondition;
  };
  
  struct s_boundary
  {
    BoundType bt;
    
    double mixedval;
  };

  struct s_property
  {
    std::string name;

    bool active;
    
    std::string coefs;
  };

  struct s_layer
  {
    int layerzdepth;
    
    std::string layerpropname;
  };

  struct s_precon
  {
    PreconType type;
    double relaxation;
  };

// protected member data and definitions
protected:

  char * filename;
  
  std::ifstream file;
  
  Dimension domain;

  bool isContiguouslyBound;

  s_boundary contiguousBoundary;

  std::vector<s_boundary> boundaries;

  std::vector<s_sphericalanomaly> spherical_anomalies;

  std::vector<s_cubicalanomaly>   cubical_anomalies;
  
  std::vector<s_ellipsoidalanomaly> ellipsoidal_anomalies;

  std::vector<s_circularanomaly> circular_anomalies;
  
  std::vector<s_squareanomaly> square_anomalies;

  std::vector <s_node> nodes;

  std::vector <s_monopolesource>  monopole_sources;
  
  std::vector <s_dipolesource>    dipole_sources;
  
  std::vector <s_arbitrarysource> arbitrary_sources;

  int currSrcId;

  std::vector <s_monopoledetector> monopole_detectors;
  
  std::vector <s_dipoledetector>   dipole_detectors;
  
  std::vector <s_arbitrarydetector> arbitrary_detectors;

  int currDetId;

  BackgroundType bg_type;

  char * mapfile_path;
  
  char * arbitrary_prop_path;
  
  std::vector<s_layer> layers;
  
  std::string constantprop_name;



  int solver_iterations;
  
  double solver_residualtol;
  
  
  s_precon solver_conditionertype;
  
  FDDlib::enum_solver solver_type;
  
  int n_normalOrder;
  
  int n_numNeighbors;
  
  double n_normalTol;


  std::vector <s_property> props;

  GridType grid_type;

  s_arbcartgrid *acg;

  s_regcartgrid     *rcg;

  s_nebulousgrid    *ng;
  
  std::bitset<10> parsedTags;


// public member functions
public:

  Parser(char *path, Dimension d) throw(std::string);
  
  void parseFile() throw(std::string);
  
  Dimension getDomain() const;
  
  std::string getFilename() const;
  
  bool querySuccessfulParse() const;
  
  GridType getGridType() const;
  
  s_arbcartgrid getArbitraryCartesianGridData() const throw(std::string);
  
  s_regcartgrid getRegularCartesianGridData() const throw(std::string);
  
  s_nebulousgrid getNebulousGridData() const throw(std::string);
  
  std::vector<s_monopolesource> getMonopoleSourceData() const;
  
  std::vector<s_dipolesource> getDipoleSourceData() const;
  
  std::vector<s_arbitrarysource> getArbitrarySourceData() const;
  
  
  std::vector<s_monopoledetector> getMonopoleDetectorData() const;
  
  std::vector<s_dipoledetector> getDipoleDetectorData() const;
  
  std::vector<s_arbitrarydetector> getArbitraryDetectorData() const;
  
  std::vector<s_property> getPropertyData() const;
  
  BackgroundType getBackgroundType() const;
  
  std::string getConstantBGPropName() const;
  
  std::vector<s_layer> getBGLayers() const;
  
  std::string getMapfilePath() const throw(std::string);
  
  std::string getArbitraryPropPath() const throw(std::string);
  
  bool queryIsContiguouslyBound() const;
  
  s_boundary getContiguousBoundaryData() const throw(std::string);
  
  std::vector<s_boundary> getBoundaryData() const;
  
  std::vector<s_sphericalanomaly> getSphericalAnomalyData() const;
  
  std::vector<s_cubicalanomaly> getCubicalAnomalyData() const;
  
  std::vector<s_ellipsoidalanomaly> getEllipsoidalAnomalyData() const;
  
  std::vector<s_circularanomaly> getCircularAnomalyData() const;
  
  std::vector<s_squareanomaly> getSquareAnomalyData() const;
  
  int getNormalPolyOrder() const;
  
  int getNormalNumNeighbors() const;
  
  double getNormalEstTol() const;
  
  int getSolveMaxIterations() const;
  
  double getSolveResidualTolerance() const;
  
  s_precon getPreconditionerData() const;
  
  FDDlib::enum_solver getSolverType() const;
  
// protected member functions
protected:

  void deblank(char *str) const;
  
  TagType getTagType(char buf[]) const;
  
  std::list<std::string> parseSeries(std::string series, char del) const;
  
  void parseGridTag(int pos);
  
  FDDlib::gridSide3D parseGridSide(char str[]) const;
  
  void parseSourcesTag(int pos);
  
  void parseMonopoleSource(int pos);
  
  void parseDipoleSource(int pos);
  
  void parseArbitrarySource(int pos);
  
  void parseDetectorsTag(int pos);
  
  void parseMonopoleDetector(int pos);
  
  void parseDipoleDetector(int pos);
  
  void parseArbitraryDetector(int pos);
  
  void parsePropertiesTag(int pos);
  
  void parseMediumSetupTag(int pos);
  
  void parseAnomaliesTag(int pos);
  
  void parseBoundariesTag(int pos);
  
  s_boundary parseBCType(char str[]) const;
  
  void parseOptionsTag(int pos);
  
  s_precon parsePreconditionerType(char str[]) const;
  
  FDDlib::enum_solver parseSolverType(char str[]) const;
  
  void parseNodeListTag(int pos);
  
  void parseNodeTag(int pos);
  
  void parseDeltaListTag(std::ifstream& stream, int pos);
  
  void parseDeltaFile();
};

} // end fddparse

#endif

---