funcdefaults.h

Go to the documentation of this file.

/*
  This file is part of MADNESS.

  Copyright (C) 2007,2010 Oak Ridge National Laboratory

  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

  For more information please contact:

  Robert J. Harrison
  Oak Ridge National Laboratory
  One Bethel Valley Road
  P.O. Box 2008, MS-6367

  email: harrisonrj@ornl.gov
  tel:   865-241-3937
  fax:   865-572-0680

  $Id$
*/
#ifndef MADNESS_MRA_FUNCDEFAULTS_H__INCLUDED
#define MADNESS_MRA_FUNCDEFAULTS_H__INCLUDED



#include <madness/world/world.h>
#include <madness/world/array.h>
#include <madness/world/worlddc.h>
#include <madness/tensor/tensor.h>
#include <madness/mra/key.h>

namespace madness {
    template <typename T, std::size_t NDIM> class FunctionImpl;

    static const int MAXK = 30;

    static const int MAXLEVEL = 8*sizeof(Translation)-2;

    enum BCType {BC_ZERO, BC_PERIODIC, BC_FREE, BC_DIRICHLET, BC_ZERONEUMANN, BC_NEUMANN};

    template<std::size_t NDIM>
    class BoundaryConditions {
    private:
        // Used to use STL vector but static data on  a MAC was
        // causing problems.
        BCType bc[NDIM*2];

    public:
        BoundaryConditions(BCType code=BC_FREE)
        {
            for (std::size_t i=0; i<NDIM*2; ++i) bc[i] = code;
        }

        BoundaryConditions(const BoundaryConditions<NDIM>& other)
        {
            *this = other;
        }

        BoundaryConditions<NDIM>&
        operator=(const BoundaryConditions<NDIM>& other) {
            if (&other != this) {
                for (std::size_t i=0; i<NDIM*2; ++i) bc[i] = other.bc[i];
            }
            return *this;
        }


        BCType operator()(std::size_t d, int i) const {
            MADNESS_ASSERT(d<NDIM && i>=0 && i<2);
            return bc[2*d+i];
        }


        BCType& operator()(std::size_t d, int i) {
            MADNESS_ASSERT(d<NDIM && i>=0 && i<2);
            return bc[2*d+i];
        }

        template <typename Archive>
        void serialize(const Archive& ar) {
            ar & bc;
        }


        static const char* code_as_string(BCType code) {
            static const char* codes[] = {"zero","periodic","free","Dirichlet","zero Neumann","Neumann"};
            return codes[code];
        }


        std::vector<bool> is_periodic() const {
            std::vector<bool> v(NDIM);
            for (std::size_t d=0; d<NDIM; ++d)
                v[d] = (bc[2*d]==BC_PERIODIC);
            return v;
        }
    };



    template <std::size_t NDIM>
     static
     inline
     std::ostream& operator << (std::ostream& s, const BoundaryConditions<NDIM>& bc) {
         s << "BoundaryConditions(";
         for (int d=0; d<NDIM; ++d) {
             s << bc.code_as_string(bc(d,0)) << ":" << bc.code_as_string(bc(d,1));
             if (d == NDIM-1)
                 s << ")";
             else
                 s << ", ";
         }
         return s;
     }



    template <std::size_t NDIM>
    class FunctionDefaults {
    private:
        static int k;                 
        static double thresh;          
        static int initial_level;      
        static int max_refine_level;   
        static int truncate_mode;    
        static bool refine;            
        static bool autorefine;        
        static bool debug;             
        static bool truncate_on_project; 
        static bool apply_randomize;   
        static bool project_randomize; 
        static BoundaryConditions<NDIM> bc; 
        static Tensor<double> cell ;   
        static Tensor<double> cell_width;
        static Tensor<double> rcell_width; 
        static double cell_volume;      
        static double cell_min_width;   
        static TensorType tt;                   
        static std::shared_ptr< WorldDCPmapInterface< Key<NDIM> > > pmap; 

        static void recompute_cell_info() {
            MADNESS_ASSERT(cell.dim(0)==NDIM && cell.dim(1)==2 && cell.ndim()==2);
            cell_width = cell(_,1)-cell(_,0);
            cell_volume = cell_width.product();
            cell_min_width = cell_width.min();
            rcell_width = copy(cell_width);
            for (std::size_t i=0; i<NDIM; ++i) rcell_width(i) = 1.0/rcell_width(i);
        }

    public:

        static void set_defaults(World& world);

        static int get_k() {
            return k;
        }


        static void set_k(int value) {
            k=value;
            MADNESS_ASSERT(k>0 && k<=MAXK);
        }

        static const double& get_thresh() {
            return thresh;
        }


        static void set_thresh(double value) {
            thresh=value;
        }

        static int get_initial_level() {
            return initial_level;
        }


        static void set_initial_level(int value) {
            initial_level=value;
            MADNESS_ASSERT(value>0 && value<MAXLEVEL);
        }

        static int get_max_refine_level() {
            return max_refine_level;
        }


        static void set_max_refine_level(int value) {
            max_refine_level=value;
            MADNESS_ASSERT(value>0 && value<MAXLEVEL);
        }

        static int get_truncate_mode() {
            return truncate_mode;
        }


        static void set_truncate_mode(int value) {
            truncate_mode=value;
            MADNESS_ASSERT(value>=0 && value<3);
        }

        static bool get_refine() {
            return refine;
        }


        static void set_refine(bool value) {
            refine=value;
        }

        static bool get_autorefine() {
            return autorefine;
        }


        static void set_autorefine(bool value) {
            autorefine=value;
        }

        static bool get_debug() {
            return debug;
        }


        static void set_debug(bool value) {
            debug=value;
        }

        static bool get_truncate_on_project() {
            return truncate_on_project;
        }


        static void set_truncate_on_project(bool value) {
            truncate_on_project=value;
        }

        static bool get_apply_randomize() {
            return apply_randomize;
        }

        static void set_apply_randomize(bool value) {
            apply_randomize=value;
        }


        static bool get_project_randomize() {
            return project_randomize;
        }

        static void set_project_randomize(bool value) {
            project_randomize=value;
        }

        static const BoundaryConditions<NDIM>& get_bc() {
            return bc;
        }

        static void set_bc(const BoundaryConditions<NDIM>& value) {
            bc=value;
        }

        static TensorType get_tensor_type() {
                return tt;
        }

        static void set_tensor_type(const TensorType& t) {
#if HAVE_GENTENSOR
                tt=t;
#else
                tt=TT_FULL;
#endif
        }

        static const Tensor<double>& get_cell() {
            return cell;
        }


        static void set_cell(const Tensor<double>& value) {
            cell=copy(value);
            recompute_cell_info();
        }


        static void set_cubic_cell(double lo, double hi) {
            cell(_,0)=lo;
            cell(_,1)=hi;
            recompute_cell_info();
        }

        static const Tensor<double>& get_cell_width() {
            return cell_width;
        }

        static const Tensor<double>& get_rcell_width() {
            return rcell_width;
        }

        static double get_cell_min_width() {
            return cell_min_width;
        }

        static double get_cell_volume() {
            return cell_volume;
        }

        static std::shared_ptr< WorldDCPmapInterface< Key<NDIM> > >& get_pmap() {
            return pmap;
        }


        static void set_pmap(const std::shared_ptr< WorldDCPmapInterface< Key<NDIM> > >& value) {
            pmap = value;
        }

        static void redistribute(World& world, const std::shared_ptr< WorldDCPmapInterface< Key<NDIM> > >& newpmap) {
            pmap->redistribute(world,newpmap);
            pmap = newpmap;
        }

    };


    template <std::size_t NDIM>
    static inline void user_to_sim(const Vector<double,NDIM>& xuser, Vector<double,NDIM>& xsim) {
        for (std::size_t i=0; i<NDIM; ++i)
            xsim[i] = (xuser[i] - FunctionDefaults<NDIM>::get_cell()(i,0)) * FunctionDefaults<NDIM>::get_rcell_width()[i];
    }


    template <std::size_t NDIM>
    static void sim_to_user(const Vector<double,NDIM>& xsim, Vector<double,NDIM>& xuser) {
        for (std::size_t i=0; i<NDIM; ++i)
            xuser[i] = xsim[i]*FunctionDefaults<NDIM>::get_cell_width()[i] + FunctionDefaults<NDIM>::get_cell()(i,0);
    }


}
#endif // MADNESS_MRA_FUNCDEFAULTS_H__INCLUDED