---

FiniteDifferences2D.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 _FINITE_DIFF2D_H_
#define _FINITE_DIFF2D_H_

#include "ArbitraryCartesianGrid2D.h"
#include "CartesianNode2D.h"
#include "grid_enums.h"
#include "SparseRowMatrix.h"
#include "Source2D.h"
#include "Detector2D.h"
#include "ComplexVector.h"
#include "Preconditioner.h"
#include <string>
#include <vector>
#include <map>
#include "solver.h"
#include "BoundaryCondition2D.h"

namespace FDDlib {

class FiniteDifferences2D
{
protected:

  struct s_neighbordata {
    CartesianNode2D* n_node;
    int n_linearIndex;
  };

  ArbitraryCartesianGrid2D *grid;
  
  static const int UNKNOWN_VALUE = -10;
  
  static const int OMITVAL = -1;

  SparseRowMatrix<double> Amat_;

  ComplexVector<double> Phi_;

  ComplexVector<double> AdjointPhi_;

  int startTime;

  int stopTime;

  double achievedTol_;

  int usedIterations_;

  int currSrcNum_;

  double currFreq_;
  
  int numUnknowns;
  
  std::map<int, Complex<double> > knowns;
  
  std::vector<BoundaryCondition2D*> bconds_;
  
  SparseRowMatrix<double> Adep;

  std::vector<int> rowMap;

  bool validAndActive(const s_neighbordata& ndata) const;
  
  double getOffDiagVal(const CartesianNode2D& node,
                       const CartesianNode2D& node_p,
                       const CartesianNode2D& node_m, 
                       direction2D dir) const;
  
  void resetDataVector(std::vector<s_neighbordata>& datavec) const;

  void buildAMatrix(double omega) throw(std::string);
  
  void postProcessAMatrix();
  
  void updateRightHandSide(RealVector<double>& RHS);

  void copySubMatrices();
  
public:

  FiniteDifferences2D(ArbitraryCartesianGrid2D* acg3d, 
                      const std::vector<BoundaryCondition2D*>& bconds);

  void SingleSrcSolve(int solveIterations, double residualTol,
                     const Source2D &src,
                     const std::vector<Detector2D*> &detarr,
                     Preconditioner& Pre, enum_solver Solver,
                     void (*callback)(const FiniteDifferences2D&, bool,
                           const std::vector<Detector2D*>&)) throw(std::string);

  void MultipleSrcSolve(int solveIterations, double residualTol,
                         const std::vector<Source2D*> &srcarr,
                         const std::vector<Detector2D*> &detarr,
                         Preconditioner& Pre, enum_solver Solver,
                         void (*callback)(const FiniteDifferences2D&, bool,
                               const std::vector<Detector2D*>&)) throw(std::string);

  bool AdjointSolve(int solveIterations, double residualTol,
                   const Detector2D &adjDetector, double frequency,
                   Preconditioner& Pre, enum_solver Solver) throw(std::string);

  bool solve(int solveIterations, double residualTol,
            bool adjoint, Preconditioner& Pre,
            RealVector<double>& RHS, enum_solver Solver) throw(std::string);

  ComplexVector<double> getPhi() const;

  ComplexVector<double> getAdjointPhi() const;

  void getPhi(RealVector<double>& realvec, RealVector<double>& imagvec) const;

  void getAdjointPhi(RealVector<double>& realvec,
                     RealVector<double>& imagvec) const;

  void getStatistics(double& solveTime, double& achievedTol,
                     int& usedIterations) const;

  void getSourceInfo(int& srcNum, double& freq) const;
  
};

}

#endif

---