]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Make deal.II compilable with gcc2.8
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 23 Mar 1998 07:44:41 +0000 (07:44 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Mon, 23 Mar 1998 07:44:41 +0000 (07:44 +0000)
git-svn-id: https://svn.dealii.org/trunk@88 0785d39b-7218-0410-832d-ea1e28bc413d

23 files changed:
deal.II/base/include/base/function.h
deal.II/base/include/base/parameter_handler.h
deal.II/base/source/parameter_handler.cc
deal.II/deal.II/Attic/examples/Makefile
deal.II/deal.II/Todo
deal.II/deal.II/include/dofs/dof_accessor.h
deal.II/deal.II/include/dofs/dof_handler.h
deal.II/deal.II/include/fe/fe.h
deal.II/deal.II/include/grid/tria.h
deal.II/deal.II/include/grid/tria_iterator.h
deal.II/deal.II/include/numerics/base.h
deal.II/deal.II/include/numerics/data_io.h
deal.II/deal.II/source/dofs/dof_accessor.cc
deal.II/deal.II/source/dofs/dof_constraints.cc
deal.II/deal.II/source/dofs/dof_handler.cc
deal.II/deal.II/source/fe/Makefile
deal.II/deal.II/source/fe/fe_lib.linear.cc
deal.II/deal.II/source/grid/Makefile
deal.II/deal.II/source/grid/tria.cc
deal.II/deal.II/source/grid/tria_accessor.cc
deal.II/deal.II/source/numerics/Makefile
deal.II/deal.II/source/numerics/base.cc
tests/big-tests/Makefile

index b70514af93b8c7b4ae43a6952347530f6db5b881..a00e86d2a634cbba93f316758b4aabfbc3646d7d 100644 (file)
@@ -1,5 +1,5 @@
 /*----------------------------   function.h     ---------------------------*/
-/*      <Id:>                 */
+/*      $Id$                 */
 #ifndef __function_H
 #define __function_H
 /*----------------------------   function.h     ---------------------------*/
index 81aff2ad101b52962b48e812a412633844944130..810debb6ae7eef2b9bf91aa1cb6eb94210c6a41d 100644 (file)
@@ -6,8 +6,8 @@
 
 
 // public classes; to be declared below
-class                            ParameterHandler;
-template <class UserClass> class MultipleParameterLoop;
+class ParameterHandler;
+class MultipleParameterLoop;
 
 
 #include <map.h>
@@ -464,6 +464,14 @@ class ParameterHandler {
                                      */
     ParameterHandler ();
 
+                                    /**
+                                     * Destructor. Declare this only to have
+                                     * a virtual destructor, which is safer
+                                     * as we have virtual functions.
+                                     * It actually does nothing spectacular.
+                                     */
+    virtual ~ParameterHandler ();
+    
                                     /**
                                      * Read input from a stream until stream
                                      * returns #eof# condition or error.
@@ -720,7 +728,7 @@ class ParameterHandler {
                                      */
     const Section* get_present_changed_subsection () const;
 
-  friend class MultipleParameterLoop;
+    friend class MultipleParameterLoop;
 };
 
        
@@ -982,6 +990,14 @@ class MultipleParameterLoop : public ParameterHandler {
                                      */
     MultipleParameterLoop ();
 
+                                    /**
+                                     * Destructor. Declare this only to have
+                                     * a virtual destructor, which is safer
+                                     * as we have virtual functions.
+                                     * It actually does nothing spectacular.
+                                     */
+    virtual ~MultipleParameterLoop ();
+
                                     /**
                                      * Read input from a stream until stream
                                      * returns #eof# condition or error.
index 9471f0caf1e73431c64714006707b7355b81f8a3..6b0b5d3a8e38bbdec49572eaaaf771b3d0b2e084 100644 (file)
@@ -32,6 +32,10 @@ ParameterHandler::ParameterHandler () :
                status(true) {};
 
 
+ParameterHandler::~ParameterHandler () {};
+
+
+
 bool ParameterHandler::read_input (istream &input) {
   String line;
   int lineno=0;
@@ -536,8 +540,7 @@ bool ParameterHandler::scan_line (String line, const unsigned int lineno) {
 
 ParameterHandler::Section* ParameterHandler::get_present_defaults_subsection () {
   Section* sec = &defaults;
-  vector<String>::const_iterator SecName;
-  SecName = subsection_path.begin();
+  vector<String>::const_iterator SecName = subsection_path.begin();
     
   while (SecName != subsection_path.end()) 
     {
@@ -551,20 +554,24 @@ ParameterHandler::Section* ParameterHandler::get_present_defaults_subsection ()
 
 
 const ParameterHandler::Section* ParameterHandler::get_present_defaults_subsection () const {
-                                  // simply call the non-const version
-                                  // of this function
-  typedef Section* (ParameterHandler::*xptr) ();
-  xptr x = &get_present_defaults_subsection;
+  Section* sec = (Section*)&defaults; // not nice, but needs to be and
+                                  // after all: we do not change #sec#
+  vector<String>::const_iterator SecName = subsection_path.begin();
+    
+  while (SecName != subsection_path.end()) 
+    {
+      sec = sec->subsections[*SecName];
+      ++SecName;
+    };
 
-  return x();
+  return sec;
 };
 
 
 
 ParameterHandler::Section* ParameterHandler::get_present_changed_subsection () {
   Section* sec = &changed_entries;
-  vector<String>::iterator SecName;
-  SecName = subsection_path.begin();
+  vector<String>::iterator SecName = subsection_path.begin();
     
   while (SecName != subsection_path.end()) 
     {
@@ -578,12 +585,16 @@ ParameterHandler::Section* ParameterHandler::get_present_changed_subsection () {
 
 
 const ParameterHandler::Section* ParameterHandler::get_present_changed_subsection () const {
-                                  // simply call the non-const version
-                                  // of this function
-  typedef Section* (ParameterHandler::*xptr) ();
-  xptr x = &get_present_changed_subsection;
+  Section* sec = (Section*)&changed_entries; // same as in get_present_default_s...
+  vector<String>::const_iterator SecName = subsection_path.begin();
+    
+  while (SecName != subsection_path.end()) 
+    {
+      sec = sec->subsections[*SecName];
+      ++SecName;
+    };
 
-  return x();
+  return sec;
 };
 
 
@@ -608,6 +619,9 @@ MultipleParameterLoop::MultipleParameterLoop() :
                n_branches(0) {};
 
 
+MultipleParameterLoop::~MultipleParameterLoop () {};
+
+
 bool MultipleParameterLoop::read_input (istream &input) {
   bool x = ParameterHandler::read_input (input);
   if (x) init_branches ();
index 6c77979105208df48a0d3030c4ed59cbbbad1701..5825f83c2eed8f24cf2fd997be41d9e82055cc2f 100644 (file)
@@ -14,8 +14,13 @@ LIBS.g    = $(LIBPATH) -lbasic.g -lgrid.g -lfe.g -lnumerics.g -llac.g
 LIBS      = $(LIBS.g:.g=)
 
 ifeq ($(shell uname),SunOS)
-CXXFLAGS  := -V2.7.2.3 $(CXXFLAGS)
-CXXFLAGS.g:= -V2.7.2.3 $(CXXFLAGS.g)
+#CXXFLAGS  := -V2.7.2.3 $(CXXFLAGS)
+#CXXFLAGS.g:= -V2.7.2.3 $(CXXFLAGS.g)
+INCLUDE2.8  =  -I/usr/local/source/libstdc++-2.8.0/libstdc++ \
+               -I/usr/local/source/libstdc++-2.8.0/libstdc++/stl \
+               -I/usr/local/source/libstdc++-2.8.0/libio
+CXXFLAGS  := $(CXXFLAGS) -fno-rtti -fno-exceptions $(INCLUDE2.8)
+CXXFLAGS.g:= $(CXXFLAGS.g) -W -fno-rtti -fno-exceptions $(INCLUDE2.8)
 endif
 
 
index ac08c1d01bbf264eebca3a397cc20f35a86a7804..4086d29f8fcbacb2b0ca5f2a480fc6a43a3d2296 100644 (file)
@@ -39,6 +39,8 @@ Make AssemblerData a local class to Assembler again if gcc2.8 supports it.
 Let ParameterHandler and DataIn/Out throw exceptions. Make more tests
   on the input.
   
+Replace function objects by mem_fun, fun_ptr, ... when member function
+  templates are supported.
 
 
 
index 87d4791d7f21b4fb276a4e2056a8558b629cac81..57cad67c7f553880b694417d00474bb34416f52f 100644 (file)
@@ -7,11 +7,9 @@
 
 template <int dim> class Triangulation;
 template <int dim> class DoFHandler;
-template <class T> class vector;
-
 
 #include <grid/tria_accessor.h>
-
+#include <vector.h>
 
 
 
@@ -45,6 +43,16 @@ class DoFAccessor {
                                      * Exception for child classes
                                      */
     DeclException0 (ExcInvalidObject);
+                                    /**
+                                     * Exception for child classes
+                                     */
+    DeclException3 (ExcInvalidIndex,
+                   int,
+                   int,
+                   int,
+                   << "Invalid index " << arg1
+                   << ", index must be between " << arg2
+                   << " and " << arg3 << ".");
 
   protected:
                                     /**
index 78a868da31c12ae8f78393dd57df784093caa972..e8fcc9713f7391bb9a6673d27159b576a24961e5 100644 (file)
@@ -413,6 +413,22 @@ enum RenumberingMethod {
 template <int dim>
 class DoFHandler : public DoFDimensionInfo<dim> {
   public:
+                                    // insert these definitions for gcc2.8,
+                                    // since it can't inherit typedefs (I
+                                    // believe it should, but it can't)
+    typedef typename DoFDimensionInfo<dim>::raw_line_iterator raw_line_iterator;
+    typedef typename DoFDimensionInfo<dim>::line_iterator line_iterator;
+    typedef typename DoFDimensionInfo<dim>::active_line_iterator active_line_iterator;
+
+    typedef typename DoFDimensionInfo<dim>::raw_quad_iterator raw_quad_iterator;
+    typedef typename DoFDimensionInfo<dim>::quad_iterator quad_iterator;
+    typedef typename DoFDimensionInfo<dim>::active_quad_iterator active_quad_iterator;
+
+    typedef typename DoFDimensionInfo<dim>::raw_cell_iterator raw_cell_iterator;
+    typedef typename DoFDimensionInfo<dim>::cell_iterator cell_iterator;
+    typedef typename DoFDimensionInfo<dim>::active_cell_iterator active_cell_iterator;
+
+
                                     /**
                                      * Constructor. Take #tria# as the
                                      * triangulation to work on.
index d23143ef7e9de8a6681c6d65f761ca8ce7777288..7757b1148f27e97be582e47b42ecba8974951eb1 100644 (file)
@@ -238,12 +238,12 @@ class FiniteElementBase {
                                      */
     FiniteElementBase (const FiniteElementBase &f);
 
-//                                  /**
-//                                   * Destructor. Only declared to have a
-//                                   * virtual destructor which the compiler
-//                                   * wants to have.
-//                                   */
-//    virtual ~FiniteElementBase () {};
+                                    /**
+                                     * Destructor. Only declared to have a
+                                     * virtual destructor which the compiler
+                                     * wants to have.
+                                     */
+    virtual ~FiniteElementBase () {};
     
 
                                     /**
index a7eea19f2d3a336d0511f200b7f6281506416486..5bd827fa3a55455fc9b53b0e142c4367b9179ceb 100644 (file)
@@ -857,6 +857,21 @@ class TriaDimensionInfo<2> {
 template <int dim>
 class Triangulation : public TriaDimensionInfo<dim> {
   public:
+                                    // insert these definitions for gcc2.8,
+                                    // since it can't inherit typedefs (I
+                                    // believe it should, but it can't)
+    typedef typename TriaDimensionInfo<dim>::raw_line_iterator raw_line_iterator;
+    typedef typename TriaDimensionInfo<dim>::line_iterator line_iterator;
+    typedef typename TriaDimensionInfo<dim>::active_line_iterator active_line_iterator;
+
+    typedef typename TriaDimensionInfo<dim>::raw_quad_iterator raw_quad_iterator;
+    typedef typename TriaDimensionInfo<dim>::quad_iterator quad_iterator;
+    typedef typename TriaDimensionInfo<dim>::active_quad_iterator active_quad_iterator;
+
+    typedef typename TriaDimensionInfo<dim>::raw_cell_iterator raw_cell_iterator;
+    typedef typename TriaDimensionInfo<dim>::cell_iterator cell_iterator;
+    typedef typename TriaDimensionInfo<dim>::active_cell_iterator active_cell_iterator;
+
                                     /**
                                      *  Create a triangulation and create
                                      *  the first level of the hierarchy.
index 9e260ee31ee53e2e4788c77105fae63c9b873e72..9521b5a2c65a343b3074d2a432103b683b82b2ba 100644 (file)
@@ -223,7 +223,7 @@ template <int dim> class Triangulation;
     @author Wolfgang Bangerth, 1998
  */
 template <int dim, class Accessor>
-class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
+class TriaRawIterator : public bidirectional_iterator<Accessor,int>{
   public:
                                     /**
                                      *  Empty constructor. Such an object
index 2a5f1e94f483fce3382263a644dd56dede412e52..7b2772ef41eb25513c0617ea58152bc38fa5a130 100644 (file)
@@ -16,7 +16,7 @@ template <int dim> class DoFHandler;
 template <int dim> class FiniteElement;
 template <int dim> class Quadrature;
 template <int dim> class DataOut;
-
+template <int dim> class Function;
 
 
 
@@ -46,6 +46,14 @@ template <int dim> class DataOut;
     \item Condense the system matrix and right hand side with the constraints
       induced by hanging nodes.
   \end{itemize}
+
+
+  {\bf Solving}
+
+  Calling the #solve# function with a solver object, the system of equations
+  which results after having called the #assemble# function is solved. After
+  this, the solution vector is distributed again, i.e. the constrained nodes
+  are given their correct values.
   */
 template <int dim>
 class ProblemBase {
@@ -60,6 +68,14 @@ class ProblemBase {
     ProblemBase (Triangulation<dim> *tria,
                 DoFHandler<dim>    *dof_handler);
 
+                                    /**
+                                     * Destructor. Declare this only to have
+                                     * a virtual destructor, which is safer
+                                     * as we have virtual functions.
+                                     * It actually does nothing spectacular.
+                                     */
+    virtual ~ProblemBase ();
+
                                     /**
                                      * Initiate the process of assemblage of
                                      * vectors and system matrix. Use the
@@ -74,8 +90,81 @@ class ProblemBase {
                           const FiniteElement<dim> &fe);
 
 
-    void solve ();
-    void fill_data (DataOut<dim> &) const;
+                                    /**
+                                     * Solve the system of equations.
+                                     */
+    virtual void solve ();
+
+                                    /**
+                                     * Integrate the difference between
+                                     * the solution computed before and
+                                     * the reference solution, which
+                                     * is given as a continuous function
+                                     * object. The integration is
+                                     * performed using the given quadrature
+                                     * rule and assumes that the given
+                                     * finite element objects equals
+                                     * that used for the computation of
+                                     * the solution.
+                                     *
+                                     * The result ist stored in the
+                                     * #difference# object, where each
+                                     * entry equals the L_1 norm of
+                                     * the difference on one cell. The
+                                     * order of entries is the same as
+                                     * a #cell_iterator# takes when
+                                     * started with #begin_active# and
+                                     * promoted with the #++# operator.
+                                     *
+                                     * You can use the
+                                     * #distribute_cell_to_dof_vector#
+                                     * function to convert cell based
+                                     * data to a data vector with values
+                                     * on the degrees of freedom, which
+                                     * can then be attached to a
+                                     * #DataOut# object.
+                                     *
+                                     * To get the global L_1 error,
+                                     * you have to sum up the entries
+                                     * in #difference#, e.g. using the STL
+                                     * function
+                                     * #accumulate (d.begin(), d.end(), 0)#,
+                                     * if #d# is the difference vector.
+                                     */
+    void integrate_L1_difference (const Function<dim>      &exact_solution,
+                                 vector<double>           &difference,
+                                 const Quadrature<dim>    &q,
+                                 const FiniteElement<dim> &fe) const;
+    
+                                    /**
+                                     * Initialize the #DataOut# object with
+                                     * the grid and DoF handler used for this
+                                     * computation, as well as with the
+                                     * solution. Overload this function if
+                                     * you have multiple data sets to be
+                                     * written, or alternativelt call this
+                                     * function and attach the additional
+                                     * vectors directly to the #DataOut#
+                                     * object.
+                                     *
+                                     * Solution name and physical units are
+                                     * derived by calling the virtual
+                                     * function #get_solution_name#.
+                                     */
+    virtual void fill_data (DataOut<dim> &) const;
+
+
+                                    /**
+                                     * Return solution name and
+                                     * physical units as a pair of
+                                     * #char*#. The default implementation
+                                     * returns #make_pair ("solution","")#,
+                                     * which results in "<dimensionless>"
+                                     * upon output.
+                                     * Overload this function, if you
+                                     * want anything else.
+                                     */
+    virtual pair<char*,char*> get_solution_name () const;
     
                                     /**
                                      * Exception
@@ -85,6 +174,10 @@ class ProblemBase {
                                      * Exception
                                      */
     DeclException0 (ExcNoMemory);
+                                    /**
+                                     * Exception
+                                     */
+    DeclException0 (ExcInvalidFE);
     
   protected:
                                     /**
index 91401d1e308b3593f47026330409b9f56aa8f4f6..b55ea675ecc1ca9299a40a100667ec044bd2b76b 100644 (file)
@@ -21,7 +21,7 @@ template <int dim> class DoFHandler;
 
 class dVector;
 
-template <class Key, class T, class Compare> class map;
+template <class Key, class T, class Compare, class Alloc = alloc> class map;
 template <class T> struct less;
 
 
index 8252274496e3177be922fa25d774097ca3288a22..b7c0c6c18117cfb994abfce3dc0bf2b9ea451739 100644 (file)
@@ -99,7 +99,7 @@ DoFLineAccessor<dim,BaseClass>::child (const unsigned int i) const {
   
 #ifdef DEBUG
   if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsChild());
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
 #endif
   return q;
 };
@@ -209,7 +209,7 @@ DoFQuadAccessor<dim,BaseClass>::child (const unsigned int i) const {
   
 #ifdef DEBUG
   if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsChild());
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
 #endif
   return q;
 };
@@ -238,7 +238,7 @@ DoFCellAccessor<dim>::neighbor (const unsigned int i) const {
   
 #ifdef DEBUG
   if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsNeighbor());
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsNeighbor());
 #endif
   return q;
 };
@@ -255,7 +255,7 @@ DoFCellAccessor<dim>::child (const unsigned int i) const {
   
 #ifdef DEBUG
   if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsChild());
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
 #endif
   return q;
 };
index 66251c0e9a535f28719e0262c2fea9baf970b53c..1ec514f779bd89a801f4f4435e958ccf147bc182 100644 (file)
@@ -181,10 +181,17 @@ void ConstraintMatrix::condense (dSMatrixStruct &sparsity) const {
                                   // otherwise, the number states which
                                   // line in the constraint matrix handles
                                   // this index
+                                  //
+                                  // for gcc2.9: replace this by
+                                  // distribute(sparsity.n_rows(), -1)
   vector<int> distribute;
   distribute.reserve (sparsity.n_rows());
-  distribute.insert (distribute.end(), sparsity.n_rows(), -1);
-
+                                  // replace the following line, since
+                                  // gcc2.8 chokes over it.
+//  distribute.insert (distribute.end(), sparsity.n_rows(), -1);
+  for (unsigned int i=0; i<(unsigned int)sparsity.n_rows(); ++i)
+    distribute.push_back (-1);
+  
   for (int c=0; c<(signed int)lines.size(); ++c)
     distribute[lines[c].line] = c;
 
@@ -350,10 +357,18 @@ void ConstraintMatrix::condense (dSMatrix &uncondensed) const {
                                   // otherwise, the number states which
                                   // line in the constraint matrix handles
                                   // this index
+                                  //
+                                  // for gcc2.9: replace this by
+                                  // distribute(sparsity.n_rows(), -1)
   vector<int> distribute;
   distribute.reserve (sparsity.n_rows());
-  distribute.insert (distribute.end(), sparsity.n_rows(), -1);
+                                  // replace the following line, since
+                                  // gcc2.8 chokes over it.
+//  distribute.insert (distribute.end(), sparsity.n_rows(), -1);
+  for (unsigned int i=0; i<(unsigned int)sparsity.n_rows(); ++i)
+    distribute.push_back (-1);
 
+  
   for (int c=0; c<(signed int)lines.size(); ++c)
     distribute[lines[c].line] = c;
 
index 1eface5a241374d857daa2a1d3abc5532d41313d..a1c040bb48755cf213d51649dcbb51869a4f7a52 100644 (file)
@@ -620,7 +620,6 @@ int DoFHandler<2>::distribute_dofs_on_cell (active_cell_iterator   &cell,
 
 
 
-
 template <int dim>
 void DoFHandler<dim>::renumber_dofs (const RenumberingMethod method,
                                     bool use_constraints,
@@ -635,26 +634,38 @@ void DoFHandler<dim>::renumber_dofs (const RenumberingMethod method,
       make_constraint_matrix (constraints);
       constraints.condense (sparsity);
     };
-
+    
   int n_dofs = sparsity.n_rows();
                                   // store the new dof numbers; -1 means
                                   // that no new number was chosen yet
-  vector<int> new_number(sparsity.n_rows(), -1);
-
+                                  //
+                                  // the commented line is what would be the
+                                  // correct way to do, but gcc2.8 chokes
+                                  // over that. The other lines are a
+                                  // workaround
+//  vector<int> new_number(sparsity.n_rows(), -1);
+  vector<int> new_number;
+  new_number.reserve (sparsity.n_rows());
+  for (unsigned int i=0; i<(unsigned int)sparsity.n_rows(); ++i)
+    new_number.push_back (-1);
+  
                                   // store the indices of the dofs renumbered
                                   // in the last round. Default to starting
                                   // points
   vector<int> last_round_dofs (starting_points);
+  
                                   // delete disallowed elements
   for (unsigned int i=0; i<last_round_dofs.size(); ++i)
     if ((last_round_dofs[i]<0) || (last_round_dofs[i]>=n_dofs))
       last_round_dofs[i] = -1;
+  
   remove_if (last_round_dofs.begin(), last_round_dofs.end(),
             bind2nd(equal_to<int>(), 0));
-
+  
                                   // now if no valid points remain:
                                   // find dof with lowest coordination
                                   // number
+  
   if (last_round_dofs.size() == 0)
     {
       int          starting_point   = -1;
@@ -973,7 +984,7 @@ void DoFHandler<2>::make_sparsity_pattern (dSMatrixStruct &sparsity) const {
          sparsity.add (dofs_on_this_cell[i],
                        dofs_on_this_cell[j]);
     };
-
+  
   delete[] dofs_on_this_cell;
 };
 
@@ -1034,8 +1045,8 @@ void DoFHandler<dim>::make_transfer_matrix (const DoFHandler<dim> &transfer_from
 
 
 template <int dim>
-void DoFHandler<dim>::transfer_cell (const TriaIterator<dim,DoFCellAccessor<dim> > &old_cell,
-                                    const TriaIterator<dim,DoFCellAccessor<dim> > &new_cell,
+void DoFHandler<dim>::transfer_cell (const typename DoFHandler<dim>::cell_iterator &old_cell,
+                                    const typename DoFHandler<dim>::cell_iterator &new_cell,
                                     dSMatrixStruct      &transfer_pattern) const {
   if (!new_cell->active() && !old_cell->active())
                                     // both cells have children; go deeper
@@ -1130,8 +1141,8 @@ void DoFHandler<dim>::transfer_cell (const TriaIterator<dim,DoFCellAccessor<dim>
 
 
 template <int dim>
-void DoFHandler<dim>::transfer_cell (const TriaIterator<dim,DoFCellAccessor<dim> > &old_cell,
-                                    const TriaIterator<dim,DoFCellAccessor<dim> > &new_cell,
+void DoFHandler<dim>::transfer_cell (const typename DoFHandler<dim>::cell_iterator &old_cell,
+                                    const typename DoFHandler<dim>::cell_iterator &new_cell,
                                     dSMatrix            &transfer_matrix) const {
   if (!new_cell->active() && !old_cell->active())
                                     // both cells have children; go deeper
index debc97db8a5a50530d0ae93736c8688ebf4d6267..354115c4667c75fb4f7f17e451c4c65a246394b1 100644 (file)
@@ -9,8 +9,13 @@ CXXFLAGS  =-O3 -Wuninitialized -finline-functions -ffast-math \
            -funroll-loops -felide-constructors -fnonnull-objects $(INCLUDE)
 
 ifeq ($(shell uname),SunOS)
-CXXFLAGS  := -V2.7.2.3 $(CXXFLAGS)
-CXXFLAGS.g:= -V2.7.2.3 $(CXXFLAGS.g)
+#CXXFLAGS  := -V2.7.2.3 $(CXXFLAGS)
+#CXXFLAGS.g:= -V2.7.2.3 $(CXXFLAGS.g)
+INCLUDE2.8  =  -I/usr/local/source/libstdc++-2.8.0/libstdc++ \
+               -I/usr/local/source/libstdc++-2.8.0/libstdc++/stl \
+               -I/usr/local/source/libstdc++-2.8.0/libio
+CXXFLAGS  := $(CXXFLAGS) -fno-rtti -fno-exceptions $(INCLUDE2.8)
+CXXFLAGS.g:= $(CXXFLAGS.g) -W -fno-rtti -fno-exceptions $(INCLUDE2.8)
 endif
 
 
index 16c685166e419f884a6e9ea2dd4ac0ffca2d8a07..7edaae69eed053bd9ff92cd9567afee0042ab36e 100644 (file)
@@ -336,8 +336,8 @@ double
 FEQuadratic<dim>::shape_value (const unsigned int i,
                               const Point<dim> &) const
 {
-  Assert (i<total_dofs, ExcInvalidIndex(i));
-  Assert (false, ExcNotImplemented());
+  Assert (i<total_dofs, typename FiniteElementBase<dim>::ExcInvalidIndex(i));
+  Assert (false, typename FiniteElementBase<dim>::ExcNotImplemented());
   return 0.;
 };
 
@@ -348,8 +348,8 @@ Point<dim>
 FEQuadratic<dim>::shape_grad (const unsigned int i,
                              const Point<dim> &) const
 {
-  Assert (i<total_dofs, ExcInvalidIndex(i));
-  Assert (false, ExcNotImplemented());
+  Assert (i<total_dofs, typename FiniteElementBase<dim>::ExcInvalidIndex(i));
+  Assert (false, typename FiniteElementBase<dim>::ExcNotImplemented());
   return Point<dim> ();
 };
 
@@ -359,7 +359,7 @@ void FEQuadratic<2>::fill_fe_values (const Triangulation<2>::cell_iterator &,
                                     const vector<Point<2> >               &,
                                     vector<dFMatrix>  &,
                                     vector<Point<2> > &) const {
-  Assert (false, ExcNotImplemented());
+  Assert (false, typename FiniteElementBase<2>::ExcNotImplemented());
 };
 
 
@@ -394,8 +394,8 @@ double
 FECubic<dim>::shape_value (const unsigned int i,
                           const Point<dim> &) const
 {
-  Assert (i<total_dofs, ExcInvalidIndex(i));
-  Assert (false, ExcNotImplemented());
+  Assert (i<total_dofs, typename FiniteElementBase<dim>::ExcInvalidIndex(i));
+  Assert (false, typename FiniteElementBase<dim>::ExcNotImplemented());
   return 0.;
 };
 
@@ -406,8 +406,8 @@ Point<dim>
 FECubic<dim>::shape_grad (const unsigned int i,
                          const Point<dim> &) const
 {
-  Assert (i<total_dofs, ExcInvalidIndex(i));
-  Assert (false, ExcNotImplemented());
+  Assert (i<total_dofs, typename FiniteElementBase<dim>::ExcInvalidIndex(i));
+  Assert (false, typename FiniteElementBase<dim>::ExcNotImplemented());
   return Point<dim> ();
 };
 
@@ -417,7 +417,7 @@ void FECubic<2>::fill_fe_values (const Triangulation<2>::cell_iterator &,
                                 const vector<Point<2> >               &,
                                 vector<dFMatrix>  &,
                                 vector<Point<2> > &) const {
-  Assert (false, ExcNotImplemented());
+  Assert (false, typename FiniteElementBase<2>::ExcNotImplemented());
 };
 
 
index 6fce69f3934351a06bd0f0908e7982191ad35c5e..f6e9cdc4731f92c89553cbc6b332d8cc5efb9e26 100644 (file)
@@ -9,8 +9,13 @@ CXXFLAGS  =-O3 -Wuninitialized -finline-functions -ffast-math \
            -funroll-loops -felide-constructors -fnonnull-objects $(INCLUDE)
 
 ifeq ($(shell uname),SunOS)
-CXXFLAGS  := -V2.7.2.3 $(CXXFLAGS)
-CXXFLAGS.g:= -V2.7.2.3 $(CXXFLAGS.g)
+#CXXFLAGS  := -V2.7.2.3 $(CXXFLAGS)
+#CXXFLAGS.g:= -V2.7.2.3 $(CXXFLAGS.g)
+INCLUDE2.8  =  -I/usr/local/source/libstdc++-2.8.0/libstdc++ \
+               -I/usr/local/source/libstdc++-2.8.0/libstdc++/stl \
+               -I/usr/local/source/libstdc++-2.8.0/libio
+CXXFLAGS  := $(CXXFLAGS) -fno-rtti -fno-exceptions $(INCLUDE2.8)
+CXXFLAGS.g:= $(CXXFLAGS.g) -W -fno-rtti -fno-exceptions $(INCLUDE2.8)
 endif
 
 
index 48417272815d2294ba5d97bfb5f1fbf9a5a7c79f..0a757181b72d62a20a22272fccce3e6c0816c5b4 100644 (file)
@@ -368,7 +368,8 @@ void Triangulation<1>::create_hypercube (const double left,
   vertices.push_back (Point<1> (left));
   vertices.push_back (Point<1> (right));
 
-  vertices_used.insert (vertices_used.end(), 2, true);
+  vertices_used.push_back (true);
+  vertices_used.push_back (true);
   
   levels[0]->lines.lines.push_back (Line(0,1));
   levels[0]->lines.children.push_back (-1);
@@ -377,7 +378,7 @@ void Triangulation<1>::create_hypercube (const double left,
   levels[0]->neighbors.push_back (make_pair(-1,-1));
   levels[0]->neighbors.push_back (make_pair(-1,-1));
 
-  levels[0]->refine_flags.insert (levels[0]->refine_flags.end(), 1, false);
+  levels[0]->refine_flags.push_back (false);
 };
 
 
@@ -388,47 +389,19 @@ void Triangulation<2>::create_hypercube (const double left,
   Assert (vertices.size() == 0, ExcTriangulationNotEmpty());
   Assert (n_lines() == 0, ExcTriangulationNotEmpty());
   Assert (n_quads() == 0, ExcTriangulationNotEmpty());
-  
-                                  // create vertices
-  vertices.push_back (Point<2> (left,left));
-  vertices.push_back (Point<2> (right,left));
-  vertices.push_back (Point<2> (right,right));
-  vertices.push_back (Point<2> (left,right));
-  vertices_used.insert (vertices_used.end(), 4, true);
-                                  // create lines
-  levels[0]->lines.lines.push_back (Line (0,1));
-  levels[0]->lines.children.push_back (-1);
-  levels[0]->lines.used.push_back (true);
-  levels[0]->lines.user_flags.push_back (false);
 
-  levels[0]->lines.lines.push_back (Line (1,2));
-  levels[0]->lines.children.push_back (-1);
-  levels[0]->lines.used.push_back (true);
-  levels[0]->lines.user_flags.push_back (false);
-
-  levels[0]->lines.lines.push_back (Line (3,2));
-  levels[0]->lines.children.push_back (-1);
-  levels[0]->lines.used.push_back (true);
-  levels[0]->lines.user_flags.push_back (false);
-
-  levels[0]->lines.lines.push_back (Line (0,3));
-  levels[0]->lines.children.push_back (-1);
-  levels[0]->lines.used.push_back (true);
-  levels[0]->lines.user_flags.push_back (false);
+  const Point<2> vertices[4] = { Point<2>(left,left),
+                                Point<2>(right,left),
+                                Point<2>(right,right),
+                                Point<2>(left,right)  };
+  const int cell_vertices[1][4] = { { 0,1,2,3 } };
+  vector<vector<int> > cells (1, vector<int>());
+  cells[0].reserve (4);
+  for (unsigned int j=0; j<4; ++j)
+    cells[0].push_back (cell_vertices[0][j]);
   
-                                  // create quads
-  levels[0]->quads.quads.push_back (Quad (0,1,2,3));
-  levels[0]->quads.children.push_back (-1);
-  levels[0]->quads.used.push_back (true);
-  levels[0]->quads.user_flags.push_back (false);
-  
-  levels[0]->neighbors.push_back (make_pair(-1,-1));
-  levels[0]->neighbors.push_back (make_pair(-1,-1));
-  levels[0]->neighbors.push_back (make_pair(-1,-1));
-  levels[0]->neighbors.push_back (make_pair(-1,-1));
-
-  levels[0]->refine_flags.insert (levels[0]->refine_flags.end(), 1, false);
+  create_triangulation (vector<Point<2> >(&vertices[0], &vertices[8]),
+                       cells);
 };
 
 
@@ -452,7 +425,16 @@ void Triangulation<2>::create_hyper_L (const double a, const double b) {
   const int cell_vertices[3][4] = {{0, 1, 4, 3},
                                   {1, 2, 5, 4},
                                   {3, 4, 7, 6}};
-  vector<vector<int> > cells (3, vector<int>(4,-1));
+
+                                  // with gcc2.9, uncomment this line
+                                  // and delete following workaraound
+//  vector<vector<int> > cells (3, vector<int>(4,-1));
+  vector<int> tmp;
+  tmp.reserve (4);
+  for (unsigned int i=0; i<4; ++i)
+    tmp.push_back (-1);
+  vector<vector<int> > cells (3, tmp);
+  
   for (unsigned int i=0; i<3; ++i)
     for (unsigned int j=0; j<4; ++j)
       cells[i][j] = cell_vertices[i][j];
@@ -485,7 +467,16 @@ void Triangulation<2>::create_hyper_ball (const Point<2> p, const double radius)
                                   {2, 3, 5, 4},
                                   {1, 7, 5, 3},
                                   {6, 4, 5, 7}};
-  vector<vector<int> > cells (5, vector<int>(4,-1));
+
+                                  // with gcc2.9, uncomment this line
+                                  // and delete following workaraound
+//  vector<vector<int> > cells (5, vector<int>(4,-1));
+  vector<int> tmp;
+  tmp.reserve (4);
+  for (unsigned int i=0; i<4; ++i)
+    tmp.push_back (-1);
+  vector<vector<int> > cells (5, tmp);
+
   for (unsigned int i=0; i<5; ++i)
     for (unsigned int j=0; j<4; ++j)
       cells[i][j] = cell_vertices[i][j];
@@ -550,7 +541,7 @@ void Triangulation<dim>::save_refine_flags (ostream &out) const {
 
 template <int dim>
 void Triangulation<dim>::load_refine_flags (istream &in) {
-  int magic_number;
+  unsigned int magic_number;
   in >> magic_number;
   Assert (magic_number==mn_tria_refine_flags_begin, ExcGridReadError());
 
@@ -655,7 +646,7 @@ void Triangulation<dim>::save_user_flags_line (ostream &out) const {
 
 template <int dim>
 void Triangulation<dim>::load_user_flags_line (istream &in) {
-  int magic_number;
+  unsigned int magic_number;
   in >> magic_number;
   Assert (magic_number==mn_tria_line_user_flags_begin, ExcGridReadError());
 
@@ -734,7 +725,7 @@ void Triangulation<1>::load_user_flags_quad (istream &) {
 
 template <int dim>
 void Triangulation<dim>::load_user_flags_quad (istream &in) {
-  int magic_number;
+  unsigned int magic_number;
   in >> magic_number;
   Assert (magic_number==mn_tria_quad_user_flags_begin, ExcGridReadError());
 
@@ -1664,7 +1655,7 @@ void Triangulation<1>::execute_refinement () {
            if (cell->neighbor(1).state() != valid)
              second_child->set_neighbor (1, cell->neighbor(1));
            else
-             if (cell->neighbor(1)->active)
+             if (cell->neighbor(1)->active())
                second_child->set_neighbor (1, cell->neighbor(1));
              else
                                                 // right neighbor is refined
index 353d2a457d7a593d9d934d6234b7e56b84eea7d8..7bf6e0ad95dfbd4d7a76f38c0c12f7b6b854d7a8 100644 (file)
@@ -445,74 +445,83 @@ template class QuadAccessor<2>;
 
 
 
-/*------------------------ Functions: CellAccessor<dim> ---------------------*/
 
-template <int dim>
-int CellAccessor<dim>::neighbor_index (const unsigned int i) const {
-  Assert (i<2*dim, ExcInvalidNeighbor(i));
-  return tria->levels[present_level]->neighbors[present_index*2*dim+i].second;
+
+/*------------------------ Functions: CellAccessor<1> -----------------------*/
+
+
+bool CellAccessor<1>::at_boundary () const {
+  return at_boundary(0) || at_boundary(1);
 };
 
 
 
-template <int dim>
-int CellAccessor<dim>::neighbor_level (const unsigned int i) const {
-  Assert (i<2*dim, ExcInvalidNeighbor(i));
-  return tria->levels[present_level]->neighbors[present_index*2*dim+i].first;
+
+int CellAccessor<1>::neighbor_index (const unsigned int i) const {
+  Assert (i<2*1, ExcInvalidNeighbor(i));
+  return tria->levels[present_level]->neighbors[present_index*2*1+i].second;
 };
 
 
 
-template <int dim>
-void CellAccessor<dim>::set_neighbor (const unsigned int i,
-                                     const TriaIterator<dim,CellAccessor<dim> > &pointer) const {
-  Assert (i<2*dim, ExcInvalidNeighbor(i));
-  tria->levels[present_level]->neighbors[present_index*2*dim+i].first
+
+int CellAccessor<1>::neighbor_level (const unsigned int i) const {
+  Assert (i<2*1, ExcInvalidNeighbor(i));
+  return tria->levels[present_level]->neighbors[present_index*2*1+i].first;
+};
+
+
+
+
+void CellAccessor<1>::set_neighbor (const unsigned int i,
+                                     const TriaIterator<1,CellAccessor<1> > &pointer) const {
+  Assert (i<2*1, ExcInvalidNeighbor(i));
+  tria->levels[present_level]->neighbors[present_index*2*1+i].first
     = pointer.accessor.present_level;
-  tria->levels[present_level]->neighbors[present_index*2*dim+i].second
+  tria->levels[present_level]->neighbors[present_index*2*1+i].second
     = pointer.accessor.present_index;
 };
 
 
 
-template <int dim>
-bool CellAccessor<dim>::at_boundary (const unsigned int i) const {
+
+bool CellAccessor<1>::at_boundary (const unsigned int i) const {
   Assert (used(), ExcCellNotUsed());
-  Assert (i<2*dim, ExcInvalidIndex (i,0,2*dim-1));
+  Assert (i<2*1, ExcInvalidIndex (i,0,2*1-1));
   
   return (neighbor(i).state() != valid);
 };
 
 
 
-template <int dim>
-bool CellAccessor<dim>::refine_flag_set () const {
+
+bool CellAccessor<1>::refine_flag_set () const {
   Assert (used() && active(), ExcRefineCellNotActive());
   return tria->levels[present_level]->refine_flags[present_index];
 };
 
 
 
-template <int dim>
-void CellAccessor<dim>::set_refine_flag () const {
+
+void CellAccessor<1>::set_refine_flag () const {
   Assert (used() && active(), ExcRefineCellNotActive());
   tria->levels[present_level]->refine_flags[present_index] = true;
 };
 
 
 
-template <int dim>
-void CellAccessor<dim>::clear_refine_flag () const {
+
+void CellAccessor<1>::clear_refine_flag () const {
   Assert (used() && active(), ExcRefineCellNotActive());
   tria->levels[present_level]->refine_flags[present_index] = false;
 };
 
 
 
-template <int dim>
-TriaIterator<dim,CellAccessor<dim> >
-CellAccessor<dim>::neighbor (const unsigned int i) const {
-  TriaIterator<dim,CellAccessor<dim> > q (tria, neighbor_level (i), neighbor_index (i));
+
+TriaIterator<1,CellAccessor<1> >
+CellAccessor<1>::neighbor (const unsigned int i) const {
+  TriaIterator<1,CellAccessor<1> > q (tria, neighbor_level (i), neighbor_index (i));
 
 #ifdef DEBUG
   if (q.state() != past_the_end)
@@ -523,10 +532,10 @@ CellAccessor<dim>::neighbor (const unsigned int i) const {
 
 
 
-template <int dim>
-TriaIterator<dim,CellAccessor<dim> >
-CellAccessor<dim>::child (const unsigned int i) const {
-  TriaIterator<dim,CellAccessor<dim> > q (tria, present_level+1, child_index (i));
+
+TriaIterator<1,CellAccessor<1> >
+CellAccessor<1>::child (const unsigned int i) const {
+  TriaIterator<1,CellAccessor<1> > q (tria, present_level+1, child_index (i));
 
 #ifdef DEBUG
   if (q.state() != past_the_end)
@@ -537,33 +546,117 @@ CellAccessor<dim>::child (const unsigned int i) const {
 
 
 
-template <int dim>
-bool CellAccessor<dim>::active () const {
+
+bool CellAccessor<1>::active () const {
   return !has_children();
 };
 
 
 
-/*------------------------ Functions: CellAccessor<1> -----------------------*/
+/*------------------------ Functions: CellAccessor<2> -----------------------*/
 
 
-bool CellAccessor<1>::at_boundary () const {
-  return at_boundary(0) || at_boundary(1);
+bool CellAccessor<2>::at_boundary () const {
+  return at_boundary(0) || at_boundary(1) || at_boundary(2) || at_boundary(3);
 };
 
 
 
 
-/*------------------------ Functions: CellAccessor<2> -----------------------*/
+int CellAccessor<2>::neighbor_index (const unsigned int i) const {
+  Assert (i<2*2, ExcInvalidNeighbor(i));
+  return tria->levels[present_level]->neighbors[present_index*2*2+i].second;
+};
 
 
-bool CellAccessor<2>::at_boundary () const {
-  return at_boundary(0) || at_boundary(1) || at_boundary(2) || at_boundary(3);
+
+
+int CellAccessor<2>::neighbor_level (const unsigned int i) const {
+  Assert (i<2*2, ExcInvalidNeighbor(i));
+  return tria->levels[present_level]->neighbors[present_index*2*2+i].first;
 };
 
 
 
 
+void CellAccessor<2>::set_neighbor (const unsigned int i,
+                                     const TriaIterator<2,CellAccessor<2> > &pointer) const {
+  Assert (i<2*2, ExcInvalidNeighbor(i));
+  tria->levels[present_level]->neighbors[present_index*2*2+i].first
+    = pointer.accessor.present_level;
+  tria->levels[present_level]->neighbors[present_index*2*2+i].second
+    = pointer.accessor.present_index;
+};
+
+
+
+
+bool CellAccessor<2>::at_boundary (const unsigned int i) const {
+  Assert (used(), ExcCellNotUsed());
+  Assert (i<2*2, ExcInvalidIndex (i,0,2*2-1));
+  
+  return (neighbor(i).state() != valid);
+};
+
+
+
+
+bool CellAccessor<2>::refine_flag_set () const {
+  Assert (used() && active(), ExcRefineCellNotActive());
+  return tria->levels[present_level]->refine_flags[present_index];
+};
+
+
+
+
+void CellAccessor<2>::set_refine_flag () const {
+  Assert (used() && active(), ExcRefineCellNotActive());
+  tria->levels[present_level]->refine_flags[present_index] = true;
+};
+
+
+
+
+void CellAccessor<2>::clear_refine_flag () const {
+  Assert (used() && active(), ExcRefineCellNotActive());
+  tria->levels[present_level]->refine_flags[present_index] = false;
+};
+
+
+
+
+TriaIterator<2,CellAccessor<2> >
+CellAccessor<2>::neighbor (const unsigned int i) const {
+  TriaIterator<2,CellAccessor<2> > q (tria, neighbor_level (i), neighbor_index (i));
+
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), ExcUnusedCellAsNeighbor());
+#endif
+  return q;
+};
+
+
+
+
+TriaIterator<2,CellAccessor<2> >
+CellAccessor<2>::child (const unsigned int i) const {
+  TriaIterator<2,CellAccessor<2> > q (tria, present_level+1, child_index (i));
+
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), ExcUnusedCellAsChild());
+#endif
+  return q;
+};
+
+
+
+
+bool CellAccessor<2>::active () const {
+  return !has_children();
+};
+
 
 
 
index 87d5217a12d049538c33df372fbbdc4f80c05c7a..0d09b34614b6e53726ca5ff37a4dc6b6b55055ab 100644 (file)
@@ -9,8 +9,13 @@ CXXFLAGS  =-O3 -Wuninitialized -finline-functions -ffast-math \
            -funroll-loops -felide-constructors -fnonnull-objects $(INCLUDE)
 
 ifeq ($(shell uname),SunOS)
-CXXFLAGS  := -V2.7.2.3 $(CXXFLAGS)
-CXXFLAGS.g:= -V2.7.2.3 $(CXXFLAGS.g)
+#CXXFLAGS  := -V2.7.2.3 $(CXXFLAGS)
+#CXXFLAGS.g:= -V2.7.2.3 $(CXXFLAGS.g)
+INCLUDE2.8  =  -I/usr/local/source/libstdc++-2.8.0/libstdc++ \
+               -I/usr/local/source/libstdc++-2.8.0/libstdc++/stl \
+               -I/usr/local/source/libstdc++-2.8.0/libio
+CXXFLAGS  := $(CXXFLAGS) -fno-rtti -fno-exceptions $(INCLUDE2.8)
+CXXFLAGS.g:= $(CXXFLAGS.g) -W -fno-rtti -fno-exceptions $(INCLUDE2.8)
 endif
 
 
index 106fdddfaf0133b635d8b83e6f327a7a314f5168..ae4c3ef118cdfafc45a0cbd8619f023eaaf4c650 100644 (file)
@@ -5,6 +5,7 @@
 #include <grid/dof_constraints.h>
 #include <grid/tria_iterator.h>
 #include <basic/data_io.h>
+#include <basic/function.h>
 
 #include "../../../mia/control.h"
 #include "../../../mia/vectormemory.h"
@@ -12,6 +13,8 @@
 
 
 
+
+
 extern TriaActiveIterator<1,CellAccessor<1> > __dummy1233; // for gcc2.7
 extern TriaActiveIterator<2,CellAccessor<2> > __dummy1234;
 
@@ -30,6 +33,10 @@ ProblemBase<dim>::ProblemBase (Triangulation<dim> *tria,
 
 
 
+template <int dim>
+ProblemBase<dim>::~ProblemBase () {};
+
+
 
 template <int dim>
 void ProblemBase<dim>::assemble (const Equation<dim>   &equation,
@@ -96,12 +103,48 @@ void ProblemBase<dim>::solve () {
 
 
 
+/*
+template <int dim>
+void ProblemBase<dim>::integrate_L1_difference (const Function<dim>      &exact_solution,
+                                               vector<double>           &difference,
+                                               const Quadrature<dim>    &q,
+                                               const FiniteElement<dim> &fe) const {
+  Assert (fe == dof_handler->get_selected_fe(), ExcInvalidFE());
+
+  difference.erase (difference.begin(), difference.end());
+  difference.reserve (tria->n_cells());
+
+                                  // loop over all cells
+  DoFHandler<dim>::active_dof_iterator cell = dof_handler->begin_active(),
+                                      endc = dof_handler->end();
+  for (; cell != end; ++cell) 
+    {
+      double diff=0;
+      
+      difference.push_back (diff);
+    };
+};
+*/
+
+
+
 template <int dim>
 void ProblemBase<dim>::fill_data (DataOut<dim> &out) const {
   out.clear_data_vectors ();
   out.attach_dof_handler (*dof_handler);
-  out.add_data_vector (solution, "solution");
+
+  pair<char*,char*> solution_name = get_solution_name ();
+  out.add_data_vector (solution,
+                      solution_name.first, solution_name.second);
+};
+
+
+/*
+template <int dim>
+pair<char*,char*> ProblemBase<dim>::get_solution_name () const {
+  return make_pair("solution", "");
 };
+*/
 
   
   
index 6c77979105208df48a0d3030c4ed59cbbbad1701..5825f83c2eed8f24cf2fd997be41d9e82055cc2f 100644 (file)
@@ -14,8 +14,13 @@ LIBS.g    = $(LIBPATH) -lbasic.g -lgrid.g -lfe.g -lnumerics.g -llac.g
 LIBS      = $(LIBS.g:.g=)
 
 ifeq ($(shell uname),SunOS)
-CXXFLAGS  := -V2.7.2.3 $(CXXFLAGS)
-CXXFLAGS.g:= -V2.7.2.3 $(CXXFLAGS.g)
+#CXXFLAGS  := -V2.7.2.3 $(CXXFLAGS)
+#CXXFLAGS.g:= -V2.7.2.3 $(CXXFLAGS.g)
+INCLUDE2.8  =  -I/usr/local/source/libstdc++-2.8.0/libstdc++ \
+               -I/usr/local/source/libstdc++-2.8.0/libstdc++/stl \
+               -I/usr/local/source/libstdc++-2.8.0/libio
+CXXFLAGS  := $(CXXFLAGS) -fno-rtti -fno-exceptions $(INCLUDE2.8)
+CXXFLAGS.g:= $(CXXFLAGS.g) -W -fno-rtti -fno-exceptions $(INCLUDE2.8)
 endif
 
 

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.