map_log_pas_fait.C

/*
 *  Methods not yet implemented in class Map_log
 * 
 *   (see file map.h for documentation)
 *
 */

/*
 *   Copyright (c) 2004 Philippe Grandclement
 *
 *   This file is part of LORENE.
 *
 *   LORENE 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.
 *
 *   LORENE 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 LORENE; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */


 

/*
 * $Id: map_log_pas_fait.C,v 1.16 2026/03/04 15:47:04 j_novak Exp $
 * $Log: map_log_pas_fait.C,v $
 * Revision 1.16  2026/03/04 15:47:04  j_novak
 * Added 'verbose' flag (true by default) to limit the output of poisson solvers.
 *
 * Revision 1.15  2025/03/06 09:42:41  j_novak
 * Definition of Map_XX::integrale(Scalar&).
 *
 * Revision 1.14  2025/03/04 13:16:50  j_novak
 * New complete versions of Map_af::poisson() and Map_et::poisson() for Scalar, not using Cmp.
 *
 * Revision 1.13  2023/05/26 15:42:30  g_servignat
 * Added c_est_pas_fait() to poisson_angu(Cmp)
 *
 * Revision 1.12  2016/12/05 16:17:58  j_novak
 * Suppression of some global variables (file names, loch, ...) to prevent redefinitions
 *
 * Revision 1.11  2014/10/13 08:53:06  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.10  2014/10/06 15:13:13  j_novak
 * Modified #include directives to use c++ syntax.
 *
 * Revision 1.9  2014/01/08 09:41:22  b_peres
 * change map_log_pas_fait
 *
 * Revision 1.8  2012/01/17 10:34:56  j_penner
 * *** empty log message ***
 *
 * Revision 1.7  2008/09/29 13:23:51  j_novak
 * Implementation of the angular mapping associated with an affine
 * mapping. Things must be improved to take into account the domain index.
 *
 * Revision 1.6  2006/04/25 07:21:59  p_grandclement
 * Various changes for the NS_BH project
 *
 * Revision 1.5  2005/11/24 09:25:07  j_novak
 * Added the Scalar version for the Laplacian
 *
 * Revision 1.4  2005/08/25 12:14:09  p_grandclement
 * Addition of a new method to solve the scalar Poisson equation, based on a multi-domain Tau-method
 *
 * Revision 1.3  2005/04/04 21:31:31  e_gourgoulhon
 *  Added argument lambda to method poisson_angu
 *  to deal with the generalized angular Poisson equation:
 *     Lap_ang u + lambda u = source.
 *
 * Revision 1.2  2004/11/23 12:54:45  f_limousin
 * Function poisson_frontiere(...) has two new default arguments,
 * to deal with the case of a Dirichlet + Neumann boundary condition.
 *
 * Revision 1.1  2004/06/22 08:49:58  p_grandclement
 * Addition of everything needed for using the logarithmic mapping
 *
 * 
 * $Header: /cvsroot/Lorene/C++/Source/Map/map_log_pas_fait.C,v 1.16 2026/03/04 15:47:04 j_novak Exp $
 *
 */

// headers Lorene
#include "map.h"

namespace Lorene {
void pas_fait() {
  cout << "Function not implemented for Map_log..." << endl ;
  abort() ;
}

 void Map_log::homothetie (double) {
  pas_fait() ;
}
    
 void Map_log::resize (int, double) {
  pas_fait() ;
}

 void Map_log::adapt (const Cmp&, const Param&, int) {
  pas_fait(); 
}
    
 void Map_log::dsdr (const Cmp&, Cmp&) const {
  pas_fait() ;
}
    
 void Map_log::dsdxi (const Cmp&, Cmp&) const {
  pas_fait() ;
}

 void Map_log::srdsdt (const Cmp&, Cmp&) const {
  pas_fait() ;
}

 void Map_log::srstdsdp (const Cmp&, Cmp&) const {
  pas_fait() ;
}

 void Map_log::srdsdt (const Scalar&, Scalar&) const {
  pas_fait() ;
}

 void Map_log::srstdsdp (const Scalar&, Scalar&) const {
  pas_fait() ; 
}

 void Map_log::dsdt (const Scalar&, Scalar&) const {
  pas_fait() ;
}

 void Map_log::stdsdp (const Scalar&, Scalar&) const {
  pas_fait() ;
}

 void Map_log::laplacien (const Cmp&, int, Cmp&) const {
  pas_fait() ;
}

 void Map_log::laplacien (const Scalar&, int, Scalar&) const {
  pas_fait() ;
}

 void Map_log::lapang (const Scalar&, Scalar&) const {
  pas_fait() ;
}

 Tbl* Map_log::integrale (const Scalar&) const {
  pas_fait() ;
  return 0x0 ;
}

 Tbl* Map_log::integrale (const Cmp&) const {
  pas_fait() ;
  return 0x0 ;
}

  void Map_log::poisson (const Cmp&, Param&, Cmp&, bool) const {
  pas_fait() ;
}

void Map_log::poisson_tau (const Cmp&, Param&, Cmp&) const {
  pas_fait() ;
}

  void Map_log::poisson (const Scalar&, Param&, Scalar&, bool) const {
  pas_fait() ;
}

void Map_log::poisson_tau (const Scalar&, Param&, Scalar&) const {
  pas_fait() ;
}

 void Map_log::poisson_regular (const Cmp&, int, int, double, Param&, Cmp&, Cmp&, Cmp&, 
                      Tenseur&, Cmp&, Cmp&) const {
  pas_fait() ;
}

 void Map_log::poisson_angu (const Scalar&, Param&, Scalar&, double) const {
  pas_fait() ;
}

 void Map_log::poisson_angu (const Cmp&, Param&, Cmp&, double) const {
  pas_fait() ;
}

 Param* Map_log::donne_para_poisson_vect (Param&, int) const {
  pas_fait() ;
  return 0x0 ;
}

 void Map_log::poisson_frontiere (const Cmp&, const Valeur&, int, int, Cmp&, double, double) const {
  pas_fait() ;
}

 void Map_log::poisson_frontiere_double (const Cmp&, const Valeur&, const Valeur&, int, Cmp&) const {
  pas_fait() ;
}

 void Map_log::poisson_interne (const Cmp&, const Valeur&, Param&, Cmp&) const {
  pas_fait() ;
}

  void Map_log::poisson2d (const Cmp&, const Cmp&, Param&, Cmp&, bool) const {
  pas_fait() ;
}

 void Map_log::dalembert (Param&, Scalar&, const Scalar&, const Scalar&, const Scalar&) const {
  pas_fait() ;
}

const Map_af& Map_log::mp_angu(int) const {
    pas_fait() ;
    p_mp_angu = new Map_af(*this) ;
    return *p_mp_angu ;
}

void Map_log::primr(const Scalar&, Scalar&, bool) const {
  pas_fait() ;
}

void Map_log::poisson_falloff(const Cmp&, Param&, Cmp&, int) const {
  pas_fait() ;
}

void Map_log::poisson_ylm(const Cmp&, Param&, Cmp&, int, double*) const {
  pas_fait() ;
}
}