function_common_data.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$
*/

#include <madness/mra/funcdefaults.h>

#ifndef FUNCTIONCOMMONDATA_H_
#define FUNCTIONCOMMONDATA_H_

namespace madness {

    template<typename T, std::size_t NDIM>
    class FunctionCommonData {
    private:
        static const FunctionCommonData<T, NDIM>* data[MAXK];

        void
        _init_twoscale();

        FunctionCommonData(int k) {
            this->k = k;
            npt = k;
            for (int i = 0; i < 4; ++i)
                s[i] = Slice(i * k, (i + 1) * k - 1);
            s0 = std::vector<Slice>(NDIM);
            sh = std::vector<Slice>(NDIM);
            vk = std::vector<long>(NDIM);
            vq = std::vector<long>(NDIM);
            v2k = std::vector<long>(NDIM);
            for (std::size_t i = 0; i < NDIM; ++i) {
                s0[i] = s[0];
                sh[i] = Slice(0, (k - 1) / 2);
                vk[i] = k;
                vq[i] = npt;
                v2k[i] = 2 * k;
            }
            key0 = Key<NDIM> (0, Vector<Translation, NDIM> (0));

            _init_twoscale();
            _init_quadrature(k, npt, quad_x, quad_w, quad_phi, quad_phiw,
                             quad_phit);
        }

    public:
        typedef Tensor<T> tensorT; 

        int k; 
        int npt; 
        Slice s[4]; 
        std::vector<Slice> s0; 
        std::vector<Slice> sh; 
        std::vector<long> vk; 
        std::vector<long> v2k; 
        std::vector<long> vq; 

        Key<NDIM> key0; 

        Tensor<double> quad_x; 
        Tensor<double> quad_w; 
        Tensor<double> quad_phi; 
        Tensor<double> quad_phit; 
        Tensor<double> quad_phiw; 

        Tensor<double> h0, h1, g0, g1;      
        Tensor<double> h0T, h1T, g0T, g1T;  
        Tensor<double> hg, hgT; 
        Tensor<double> hgsonly; 

        static const FunctionCommonData<T, NDIM>&
        get(int k) {
            MADNESS_ASSERT(k > 0 && k <= MAXK);
            if (!data[k-1]) data[k-1] = new FunctionCommonData<T,NDIM>(k);
            return *(data[k-1]);
        }


        static void
        _init_quadrature(int k, int npt, Tensor<double>& quad_x, Tensor<
                         double>& quad_w, Tensor<double>& quad_phi,
                         Tensor<double>& quad_phiw, Tensor<double>& quad_phit);
    };


    class Timer {

        typedef ConcurrentHashMap<int,double> map;
        typedef ConcurrentHashMap<int,double>::accessor accessor;

        map data;
        static const int itotal=-10;

    public:
        Timer() {
        }

        void accumulate(const double time) const {

            accessor acc;
            map& map2=const_cast<map&>(data);
            bool found=map2.find(acc, -10);
            if (found) {
                acc->second+=time;
            } else {
                map2.insert(std::pair<int,double>(-10,time));
            }


            int ilog=0;
            if (time<0.1) ilog=-1;
            else if (time<1.0) ilog=0;
            else if (time<10.0) ilog=1;
            else if (time<100.0) ilog=2;
            else ilog=3;

            found=map2.find(acc, ilog);
            if (found) {
                acc->second+=1.0;
            } else {
                map2.insert(std::pair<int,long>(ilog,1));
            }
        }

        void reset() const {
            map& map2=const_cast<map&>(data);
            map2.clear();
        }

        void print(std::string line="") const {

            madness::print("timing of ",line);
            typedef ConcurrentHashMap<int,double>::const_accessor accessor;
            accessor acc;
            for (int ilog=-10; ilog<4; ++ilog) {
                const bool found=data.find(acc, ilog);
                if (found) madness::print("  time spent in log(10) ", acc->first, acc->second);
            }
        }
    };



}


#endif /* FUNCTIONCOMMONDATA_H_ */