Commits

Matt Knepley committed 514cead Merge

Comments (0)

Files changed (15)

python/PETSc/packages/Chaco.py

     g = open(os.path.join(chacoDir,'make.inc'),'w')
     self.setCompilers.pushLanguage('C')
     g.write('CC = '+self.setCompilers.getCompiler()+'\n')
+    g.write('CFLAGS = '+self.setCompilers.getCompilerFlags()+'\n')
+    g.write('OFLAGS = '+self.setCompilers.getCompilerFlags()+'\n')
     self.setCompilers.popLanguage()
     g.close()
     

src/dm/mesh/examples/tests/makefile

 	-${CLINKER} -o overlap2 overlap2.o ${PETSC_DM_LIB}
 	${RM} -f overlap2.o
 
+xsifter0: xsifter0.o chkopts
+	-${CLINKER} -o xsifter0 xsifter0.o ${PETSC_DM_LIB}
+	${RM} -f xsifter0.o
 #-----------------------------------------------------------------
 runex00:
 	-@${MPIRUN} -np ${NP} ./ex00 -log_summary ${EXTRA_ARGS}

src/dm/mesh/examples/tests/xsifter0.cxx

 
 
 #undef __FUNCT__
-#define __FUNCT__ "BasicConeTest"
-PetscErrorCode BasicConeTest(const ALE_X::Obj<sifter_type>& sifter, Options options)
+#define __FUNCT__ "BasicBaseTest"
+PetscErrorCode BasicBaseTest(const ALE_X::Obj<sifter_type>& sifter, Options options)
 {
-  ALE_X::Obj<sifter_type::ConeSequence> cone = sifter_type::ConeSequence();
-  long count = 0;
+  ALE_X::Obj<sifter_type::BaseSequence> base = sifter.base();
 
   PetscFunctionBegin;
-  ALE::LogStage stage = ALE::LogStageRegister(__FUNCT__);
   ALE::LogStagePush(stage);
-  // CONTINUE: 1) fix test to retrieve the base, then the cones and send them to cout; 
-  //           2) fix default comms in "main" to be PETSC_COMM_SELF
-  for(int r = 0; r < options.iters; r++) {
-    for(sifter_type::traits::baseSequence::iterator b_iter = base->begin(); b_iter != base->end(); ++b_iter) {
-      const ALE::Obj<sifter_type::traits::coneSequence>& cone = sifter->cone(*b_iter);
-
-      for(sifter_type::traits::coneSequence::iterator c_iter = cone->begin(); c_iter != cone->end(); ++c_iter) {
-        count++;
-      }
-    }
+  std::cout << "Basic base:" << std::endl;
+  sifter_type::BaseSequence::iterator begin, end, itor;
+  begin = base.begin();
+  end   = base.end();
+  itor = begin;
+  std::cout << *itor;
+  for(; itor != end; ++itor) {
+    std::cout << ", " << *itor;
   }
   ALE::LogStagePop(stage);
-  if (count != numConeArrows*options->iters) {
-    SETERRQ2(PETSC_ERR_ARG_SIZ, "Cap count should be %d, not %d\n", numConeArrows*options->iters, count);
-  }
   PetscFunctionReturn(0);
 }
 
     ALE_X::Test::Options options(PETSC_COMM_WORLD);
     ALE::Obj<sifter_type> sifter = ALE_X::Test::SifterTest::createForkSifter(PETSC_COMM_WORLD);
 
-    ierr = BasicConeTest(sifter, options);CHKERRQ(ierr);
+    ierr = BasicBaseTest(sifter, options);CHKERRQ(ierr);
   }
   ierr = PetscFinalize();CHKERRQ(ierr);
   PetscFunctionReturn(0);

src/dm/mesh/examples/tests/xsifterTest.hh

 
 namespace ALE_X {
   namespace Test {
-    typedef ALE_X::Arrow<int,int,int>    arrow_type;
-    typedef ALE_X::Sifter<arrow_type>    sifter_type;
+    typedef ALE_X::SifterDef::Arrow<double,int,char>    arrow_type;
+    typedef ALE_X::Sifter<arrow_type>                   sifter_type;
     class SifterTest {
     public:
-      static Obj<sifter_type> createForkSifter(const int capSize = 10, const int debug = 0) {
-        Obj<sifter_type>   sifter = new sifter_type();
+      static ALE::Obj<sifter_type> createForkSifter(const int capSize = 10, const int debug = 0) {
+        ALE::Obj<sifter_type>   sifter = new sifter_type();
         for(int i = 0; i < capSize; i++) {
-          // Add an arrow from i to i mod 3 with color 0.
-          sifter->addArrow(arrow_type(i,i % 3,0));
+          // Add an arrow from i to i mod 3 with color 'X'.
+          sifter->addArrow(arrow_type((double)i,i % 3,'X'));
         }
         return sifter;
       };
       PetscInt iters; // The number of test repetitions
       Options(MPI_Comm comm = PETSC_COMM_SELF){
         PetscErrorCode ierr = ProcessOptions(comm, this); 
-        CHKERROR(ierr, "Error in Options constructor/ProcessOptions");
+        ALE::CHKERROR(ierr, "Error in Options constructor/ProcessOptions");
       };
       //
+      #undef  __FUNCT__
       #define __FUNCT__ "ProcessOptions"
       PetscErrorCode ProcessOptions(MPI_Comm comm, Options *options)
       {

src/dm/mesh/sieve/ALE_mem.hh

   }
 
 #ifdef ALE_USE_LOGGING
-#define ALE_ALLOCATOR logged_allocator
+#define ALE_ALLOCATOR ::ALE::logged_allocator
 #else
-#define ALE_ALLOCATOR polymorphic_allocator
+#define ALE_ALLOCATOR ::ALE::polymorphic_allocator
 #endif
 
   //

src/dm/mesh/sieve/XSifter.hh

 #ifndef included_ALE_Sifter_hh
 #define included_ALE_Sifter_hh
 
-/*
+
 #include <boost/multi_index_container.hpp>
-#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/key_extractors.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index/composite_key.hpp>
-*/
+
 #include <iostream>
 
 // ALE extensions
 #include <ALE.hh>
 #endif
 
-namespace ALE {
-  //
-  // Member extractors (based on boost::multi_index)
-  //
-  template <typename Rec_>
-  struct identity : public ::boost::multi_index::identity<Rec_> {};
-  
-  template <typename Rec_, typename MemberType_, typename Member_>
-  struct member : public ::boost::multi_index<Rec_, MemberType_, Member_>{};
-}
+
 namespace ALE_X { 
   
   namespace SifterDef {
     // Arrow definition
     // 
     template<typename Source_, typename Target_, typename Color_>
-    struct  Arrow { //: public ALE::def::Arrow<Source_, Target_, Color_> {
+    struct  Arrow { 
       typedef Arrow   arrow_type;
       typedef Source_ source_type;
       typedef Target_ target_type;
       typedef Color_  color_type;
-      source_type source;
-      target_type target;
-      color_type  color;
+      source_type _source;
+      target_type _target;
+      color_type  _color;
+      //
+      source_type source() const {return this->_source;};
+      target_type target() const {return this->_target;};
+      color_type  color()  const {return this->_color;};
       // Basic
-      Arrow(const source_type& s, const target_type& t, const color_type& c) : source(s), target(t), color(c) {};
+      Arrow(const source_type& s, const target_type& t, const color_type& c) : _source(s), _target(t), _color(c) {};
       // Rebinding
       template <typename OtherSource_, typename OtherTarget_, typename OtherColor_>
       struct rebind {
       // Modifying
       struct sourceChanger {
         sourceChanger(const source_type& newSource) : _newSource(newSource) {};
-        void operator()(arrow_type& a) {a.source = this->_newSource;}
+        void operator()(arrow_type& a) {a._source = this->_newSource;}
       private:
         source_type _newSource;
       };
       //
       struct targetChanger {
         targetChanger(const target_type& newTarget) : _newTarget(newTarget) {};
-        void operator()(arrow_type& a) { a.target = this->_newTarget;}
+        void operator()(arrow_type& a) { a._target = this->_newTarget;}
       private:
         const target_type _newTarget;
       };
       //
       struct colorChanger {
         colorChanger(const color_type& newColor) : _newColor(newColor) {};
-        void operator()(arrow_type& a) { a.color = this->_newColor;}
+        void operator()(arrow_type& a) { a._color = this->_newColor;}
       private:
         const color_type _newColor;
       };
       typedef XXXOrder_                                                        xxx_order_type;
       //
       typedef lex1<key_type, key_order_type>                                   order1_type;
-      typedef lex2<key_type, arrow_type, key_order_type, xxx_order_type>       order2_type;
+      typedef lex2<key_type, rec_type, key_order_type, xxx_order_type>         order2_type;
     private:
     public:
       bool operator()(const rec_type& rec1, const rec_type& rec2) { 
              typename ColorOrder_  = std::less<typename Arrow_::color_type> >
     struct SourceColorOrder : 
       public RecKeyXXXOrder<Arrow_, 
-                              ALE::member<Arrow_,typename Arrow_::source_type,&Arrow_::source>, SourceOrder_, 
-                              RecKeyOrder<Arrow_, ALE::member<Arrow_,typename Arrow_::color_type,&Arrow_::color>, ColorOrder_>
+                            ::boost::multi_index::const_mem_fun<Arrow_,typename Arrow_::source_type, &Arrow_::source>, 
+                            SourceOrder_, 
+                            RecKeyOrder<Arrow_, 
+                                        ::boost::multi_index::const_mem_fun<Arrow_, typename Arrow_::color_type, &Arrow_::color>, 
+                                        ColorOrder_>
       >
     {};
     
              typename SourceOrder_ = std::less<typename Arrow_::source_type>
     >
     struct ColorSourceOrder : 
-      public RecKeyXXXOrder<Arrow_, ALE::member<Arrow_,typename Arrow_::color_type,&Arrow_::source>, ColorOrder_,
-                              RecKeyOrder<Arrow_, ALE::member<Arrow_,typename Arrow_::source_type,&Arrow_::source>, SourceOrder_>
+      public RecKeyXXXOrder<Arrow_, 
+                            ::boost::multi_index::const_mem_fun<Arrow_,typename Arrow_::color_type, &Arrow_::source>, 
+                            ColorOrder_,
+                            RecKeyOrder<Arrow_, 
+                                        ::boost::multi_index::const_mem_fun<Arrow_, typename Arrow_::source_type, &Arrow_::source>, 
+                                        SourceOrder_>
       >
     {};
     //
              typename TargetOrder_ = std::less<typename Arrow_::source_type>,
              typename ColorOrder_  = std::less<typename Arrow_::color_type> >
     struct TargetColorOrder : 
-      public RecKeyXXXOrder<Arrow_, ALE::member<Arrow_,typename Arrow_::source_type,&Arrow_::source>, TargetOrder_,
-                              RecKeyOrder<Arrow_, ALE::member<Arrow_,typename Arrow_::color_type,&Arrow_::color>, ColorOrder_>
+      public RecKeyXXXOrder<Arrow_, 
+                            ::boost::multi_index::const_mem_fun<Arrow_,typename Arrow_::source_type, &Arrow_::source>, 
+                            TargetOrder_,
+                            RecKeyOrder<Arrow_, 
+                                        ::boost::multi_index::const_mem_fun<Arrow_, typename Arrow_::color_type, &Arrow_::color>, 
+                                        ColorOrder_>
       >
     {};
     //
              typename ColorOrder_  = std::less<typename Arrow_::color_type>,
              typename TargetOrder_ = std::less<typename Arrow_::source_type> >
     struct ColorTargetOrder : 
-      public RecKeyXXXOrder<Arrow_, ALE::member<Arrow_,typename Arrow_::color_type,&Arrow_::source>, ColorOrder_,
-                              RecKeyOrder<Arrow_, ALE::member<Arrow_,typename Arrow_::source_type,&Arrow_::source>, TargetOrder_>
+      public RecKeyXXXOrder<Arrow_, 
+                            ::boost::multi_index::const_mem_fun<Arrow_,typename Arrow_::color_type, &Arrow_::source>, 
+                            ColorOrder_,
+                            RecKeyOrder<Arrow_, 
+                                        ::boost::multi_index::const_mem_fun<Arrow_, typename Arrow_::source_type, &Arrow_::source>, 
+                                        TargetOrder_>
       >
     {};
   
     // the outer keys from a given range and a fixed inner key.
     // Upon dereferencing values are extracted from each result record using a ValueExtractor_ object.
     template <typename Index_, typename OuterKeyExtractor_, typename InnerKeyExtractor_, 
-              typename ValueExtractor_ = ALE::identity<typename Index_::value_type>, bool inner_strided_flag = false >
+              typename ValueExtractor_ = ::boost::multi_index::identity<typename Index_::value_type>, bool inner_strided_flag = false >
     struct StridedIndexSequence {
       typedef Index_                                           index_type;
       typedef OuterKeyExtractor_                               outer_key_extractor_type;
         virtual bool              operator==(const iterator& iter) const {return this->_itor == iter._itor;};
         virtual bool              operator!=(const iterator& iter) const {return this->_itor != iter._itor;};
         // FIX: operator*() should return a const reference, but it won't compile that way, because _ex() returns const value_type
-        virtual const value_type  operator*() const {_ex(*(this->_itor));};
+        virtual const value_type  operator*() const {return _ex(*(this->_itor));};
         virtual iterator   operator++() {
           this->_sequence.next(this->_itor, this->_segBndry, inner_strided_flag);
           return *this;
       outer_key_type  _ihigh, _ilow;
       bool            _have_ilow, _have_ihigh;
       //
-      outer_key_extractor _okex;
-      inner_key_extractor _ikex;
+      outer_key_extractor_type _okex;
+      inner_key_extractor_type _ikex;
     public:
       //
       // Basic interface
       //
-      StridedIndexSequence(const OuterIndexSequence& seq) : _index(seq._index), _olow(seq._olow), _ohigh(seq._ohigh), _have_olow(seq._have_olow), _have_ohigh(seq._have_ohigh), _ilow(seq._ilow), _ihigh(seq._ihigh), _have_ilow(seq._have_ilow), _have_ihigh(seq._have_ihigh)
+      StridedIndexSequence(const StridedIndexSequence& seq) : _index(seq._index), _olow(seq._olow), _ohigh(seq._ohigh), _have_olow(seq._have_olow), _have_ohigh(seq._have_ohigh), _ilow(seq._ilow), _ihigh(seq._ihigh), _have_ilow(seq._have_ilow), _have_ihigh(seq._have_ihigh)
       {};
       StridedIndexSequence(index_type& index)  :  _index(index) {
         this->_have_olow = false; this->_have_ohigh = false;
           olow = this->_okex(*itor);
           ilow = this->_ikex(*itor);
           segBndry = this->_index.upper_bound(ALE::pair<outer_key_type, inner_key_type>(olow,ilow));
-        }
+        }// inner strided
         // Otherwise, we iterate *within* a segment until its end is reached; then the following segment is started.
         else {
           // See if our advance would lead to breaching the segment boundary:
             // ASSUMPTION: index ordering operator can compare against (outer_key, inner_key) pairs
             segBndry = this->_index.upper_bound(ALE::pair<outer_key_type, inner_key_type>(olow,ilow));
           }
+        }// inner not strided
       };// next()
       //
       iterator end() {
   
   //
   // Sifter definition
-  template<typename Arrow_, typename ArrowSupportOrder_= ColorTargetOrder<Arrow_>,typename ArrowConeOrder_= ColorSourceOrder<Arrow_>, 
+  template<typename Arrow_, 
+           typename ArrowSupportOrder_= SifterDef::ColorTargetOrder<Arrow_>, 
+           typename ArrowConeOrder_   = SifterDef::ColorSourceOrder<Arrow_>, 
            typename Predicate_ = int, typename PredicateOrder_ = std::less<Predicate_> >
   struct Sifter { // struct Sifter
     //
       //
       // Re-export typedefs
       //
-      typedef arrow_type::source_type        source_type;
-      typedef arrow_type::target_type        target_type;
-      typedef arrow_type::color_type         color_type;
+      typedef typename arrow_type::source_type        source_type;
+      typedef typename arrow_type::target_type        target_type;
+      typedef typename arrow_type::color_type         color_type;
     public:
       // Predicate stored alongside the arrow data
-      predicate_type predicate;
-    }; // struct Rec
+      predicate_type _predicate;
+      predicate_type predicate() const{return this->_predicate;};
+      source_type    source() const {return this->arrow_type::source();};
+      target_type    target() const {return this->arrow_type::target();};
+    };
     //
     typedef Rec                              rec_type;
     //
     typedef std::less<typename rec_type::target_type> target_order_type;
     //
     // Rec 'downward' order type: first order by predicate, then source, then support
-    struct downward_order_type : 
-      public SifterDef::RecKeyXXXOrder<rec_type, 
-                                       typename ALE::member<rec_type, predicate_type, &rec_type::predicate>, 
-                                       predicate_order_type, 
-                                       SifterDef::RecKeyXXXOrder<rec_type,
-                                                                 ALE::member<rec_type,typename rec_type::source_type,&rec_type::source>,
-                                                                 source_order_type, ArrowSupportOrder_> > {};
+    struct downward_order_type : public 
+    SifterDef::RecKeyXXXOrder<rec_type, 
+                              typename ::boost::multi_index::const_mem_fun<rec_type, predicate_type, &rec_type::predicate>, 
+                              predicate_order_type, 
+                              SifterDef::RecKeyXXXOrder<rec_type,
+                                                        ::boost::multi_index::const_mem_fun<rec_type,
+                                                                                            typename rec_type::source_type,
+                                                                                            &rec_type::source>,
+                                                        source_order_type, ArrowSupportOrder_> > {};
     
     //
     // Rec Cone order
-    struct upward_order_type : 
-      public SifterDef::RecKeyXXXOrder<rec_type, 
-                                       typename ALE::member<rec_type, predicate_type, &rec_type::predicate>, predicate_order_type,
-                                       SifterDef::RecKeyXXXOrder<rec_type,
-                                                                 ALE::member<rec_type,typename rec_type::target_type,&rec_type::target>,
-                                                                 target_order_type, ArrowConeOrder_> >
+    struct upward_order_type : public 
+    SifterDef::RecKeyXXXOrder<rec_type, 
+                              typename ::boost::multi_index::const_mem_fun<rec_type, 
+                                                                           predicate_type, 
+                                                                           &rec_type::predicate>, 
+                              predicate_order_type,
+                              SifterDef::RecKeyXXXOrder<rec_type,
+                                                        ::boost::multi_index::const_mem_fun<rec_type,
+                                                                                            typename rec_type::target_type,
+                                                                                            &rec_type::target>,
+                                                        target_order_type, ArrowConeOrder_> >
     {};
     
     //
     public:
       typedef SifterDef::StridedIndexSequence<Index_, OuterKeyExtractor_, InnerKeyExtractor_, ValueExtractor_> super;
       typedef Sifter                                                                                           container_type;
-      typedef typename super::index_type                                                                       index;
+      typedef typename super::index_type                                                                       index_type;
+      typedef typename super::outer_key_type                                                                   outer_key_type;
+      typedef typename super::inner_key_type                                                                   inner_key_type;
+      
       // Need to extend the inherited iterators to be able to extract arrow color
       class iterator : public super::iterator {
       public:
         iterator(const typename super::iterator& super_iter) : super::iterator(super_iter) {};
-        virtual const source_type& source() const {return this->_itor->source;};
-        virtual const color_type&  color()  const {return this->_itor->color;};
-        virtual const target_type& target() const {return this->_itor->target;};
+        virtual const source_type& source() const {return this->_itor->_source;};
+        virtual const color_type&  color()  const {return this->_itor->_color;};
+        virtual const target_type& target() const {return this->_itor->_target;};
         virtual const arrow_type&  arrow()  const {return *(this->_itor);};
       };
     protected:
     // Specialized sequence types
     //
     typedef ArrowSequence<typename ::boost::multi_index::index<rec_set_type, UpwardTag>::type,
-                          ALE::member<rec_type, predicate_type, &rec_type::predicate>,
-                          ALE::identity<rec_type>,
-                          ALE::member<rec_type, target_type, &rec_type::target>, 
-                          true>                                                       BaseSequence;
+                          ::boost::multi_index::const_mem_fun<rec_type, predicate_type, &rec_type::predicate>,
+                          ::boost::multi_index::identity<rec_type>,
+                          ::boost::multi_index::const_mem_fun<rec_type, target_type, &rec_type::target>, 
+                          true>                                                       
+    BaseSequence;
 
     typedef ArrowSequence<typename ::boost::multi_index::index<rec_set_type, UpwardTag>::type,
-                          ALE::member<rec_type, predicate_type, &rec_type::predicate>,
-                          ALE::identity<rec_type>,
-                          ALE::member<rec_type, source_type, &rec_type::source> >     ConeSequence;
+                          ::boost::multi_index::const_mem_fun<rec_type, predicate_type, &rec_type::predicate>,
+                          ::boost::multi_index::identity<rec_type>,
+                          ::boost::multi_index::const_mem_fun<rec_type, source_type, &rec_type::source> >     
+    ConeSequence;
     //
     // Extended interface
     //
       this->cone(t,cseq);
       return cseq;
     };
+    void base(BaseSequence& seq) {
+      seq.reset(*this, ::boost::multi_index::get<UpwardTag>(this->_rec_set));
+    };
+    BaseSequence& base() {
+      static BaseSequence bseq;
+      this->base(bseq);
+      return bseq;
+    };
     
   protected:
     // set of arrow records

src/docs/website/documentation/changes/dev.html

 <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
 <html>
 <head>
-
-
-
-  
-  
-  
   <meta name="GENERATOR" content="Microsoft FrontPage 5.0">
-
-
-
-  
-  
-  
   <title>PETSc: Docs:&nbsp; Changes: Development</title>
 </head>
-
-
 <body style="background-color: rgb(213, 234, 255);">
-
-
-
 <table width="100%">
-
-
-
   <tbody>
-
-
-
     <tr>
-
-
-
       <td valign="top" width="25%">
-      
-      
-      
       <h1><font color="#ff0000" size="7">PETSc</font></h1>
-
-
-
-      
-      
-      
       <ul>
-
-
-
         <li><a href="../../index.html"><strong>Home</strong></a></li>
-
-
-
-      
-      
-      
       </ul>
-
-
-
       </td>
-
-
-
       <td width="75%"><!--##begin-->
-      
-      
-      
       <h1> Docs:&nbsp;Changes: Development</h1>
-
-
-
 <!--##end--> </td>
-
-
-
     </tr>
-
-
-
     <tr>
-
-
-
       <td colspan="2" width="100%">
-      
-      
-      
       <hr color="#ff5b5b" size="4"> </td>
-
-
-
     </tr>
-
-
-
     <tr>
-
-
-
       <td valign="top" width="25%">
-      
-      
-      
       <ul>
-
-
-
         <li><a href="../../download/index.html"><strong>Download</strong></a></li>
-
-
-
         <li><a href="../../features/index.html"><strong>Features</strong></a></li>
-
-
-
         <li><a href="../index.html"><strong>Documentation</strong></a>
-          
-          
-          
           <ul>
-
-
-
             <li><a href="../index.html#Manual"><strong>Manual pages and
 Users Manual</strong></a></li>
-
-
-
             <li><a href="../referencing.html"><strong>Referencing&nbsp;
 PETSc</strong></a></li>
-
-
-
             <li><a href="../tutorials/index.html"><strong>Tutorials</strong></a></li>
-
-
-
             <li><strong><a href="../installation.html">Installation</a>
               </strong></li>
-
-
-
             <li><strong><a href="index.html">Changes</a></strong>
-              
-              
-              
               <ul>
-
-
-
                 <li><font color="#ff0000">Development</font></li>
-
-
-
                 <li><a href="231.html">2.3.1</a></li>
-
-
-
                 <li><a href="230.html">2.3.0</a></li>
-
-
-
                 <li><a href="221.html">2.2.1</a></li>
-
-
-
                 <li><a href="220.html">2.2.0</a></li>
-
-
-
                 <li><a href="216.html">2.1.6</a></li>
-
-
-
                 <li><a href="215.html">2.1.5</a></li>
-
-
-
                 <li><a href="213.html">2.1.3</a></li>
-
-
-
                 <li><a href="212.html">2.1.2</a></li>
-
-
-
                 <li><a href="211.html">2.1.1</a></li>
-
-
-
                 <li><a href="21.html">2.1.0</a></li>
-
-
-
                 <li><a href="2029.html">2.0.29</a></li>
-
-
-
                 <li><a href="2028.html">2.0.28</a></li>
-
-
-
                 <li><a href="2024.html">2.0.24</a></li>
-
-
-
                 <li><a href="2022.html">2.0.22</a></li>
-
-
-
                 <li><a href="2918-21.html">2.0.21</a></li>
-
-
-
                 <li><a href="2918-21.html">2.0.18-20</a></li>
-
-
-
                 <li><a href="2017.html">2.0.17</a></li>
-
-
-
                 <li><a href="2016.html">2.0.16</a></li>
-
-
-
                 <li><a href="2015.html">2.0.15</a></li>
-
-
-
-              
-              
-              
               </ul>
-
-
-
             </li>
-
-
-
             <li><strong><a href="../troubleshooting.html">Troubleshooting</a></strong></li>
-
-
-
             <li><strong><a href="../bugreporting.html">Bug Reporting</a></strong></li>
-
-
-
             <li><strong><a href="../codemanagement.html">Code Management</a></strong></li>
-
-
-
             <li><strong><a href="../faq.html">FAQ</a> </strong></li>
-
-
-
             <li><strong><a href="../copyright.html">Copyright</a></strong>
             </li>
-
-
-
-          
-          
-          
           </ul>
-
-
-
         </li>
-
-
-
         <li><a href="../../publications/index.html"><strong>Publications</strong></a></li>
-
-
-
         <li><a href="../../miscellaneous/index.html"><strong>Miscellaneous</strong></a></li>
-
-
-        <li><a href="../miscellaneous/external.html"><strong>External Software</strong></a></li>
-
-
+        <li><a href="../miscellaneous/external.html"><strong>External
+Software</strong></a></li>
         <li><a href="../developers/index.html"><strong>Developers Site</strong></a></li>
-
-
-
-      
-      
-      
       </ul>
-
-
-
       </td>
-
-
-
       <td valign="top" width="75%"><!--##begin-->
-      
-      
-      
       <p align="center"><font color="#ff0000" size="5"><a name="CHANGES">CHANGES</a>
 in the PETSc Development Version</font></p>
-
-
-
-      
-      
-      
       <p><u><b>General:</b></u><br>
-
       </p>
-
-
-
-      
-      
       <ul>
-
-
-              <li>We have a new Semi-Lagrangian advection solver using the method of characteristics to the
-                <tt>src/contrib/semiLagrange</tt>, contributed by <a href="mailto:katz@ldeo.columbia.edu">Richard Katz</a> and <a href="mailto:mspieg@ldeo.columbia.edu">Marc Spiegelman</a> of Columbia University. Examples are
-                included.</li>
-
-
-      
-      
+        <li>We have a new Semi-Lagrangian advection solver using the
+method of characteristics to the <tt>src/contrib/semiLagrange</tt>,
+contributed by <a href="mailto:katz@ldeo.columbia.edu">Richard Katz</a>
+and <a href="mailto:mspieg@ldeo.columbia.edu">Marc Spiegelman</a> of
+Columbia University. Examples are included.</li>
+        <li>Added C99 complex support. [check configure changes below]<br>
+        </li>
       </ul>
-
-
-
-      
-      
       <p><u><b>Vec:</b></u><br>
-
       </p>
-
-
-      
-      
-      
       <ul>
-
-
-      
-      
       </ul>
-
-
-      
-      
-      
       <p><u><b>Mat:</b></u></p>
       <ul>
-        <li>Added MatCreateScatter() and MATSCATTER to easily construct efficient "restriction operators"</li>
-        <li>Removed MatConvertRegister() and friends, added (*convertfrom) to Mat function table to replace it      </li>
-
-
+        <li>Added MatCreateScatter() and MATSCATTER to easily construct
+efficient "restriction operators"</li>
+        <li>Removed MatConvertRegister() and friends, added
+(*convertfrom) to Mat function table to replace it </li>
       </ul>
-
-
-      
-      
-      
       <ul>
-
-
-      
-      
       </ul>
-
-
-      
-      
-      
       <p><u><b>PC:</b></u></p>
       <ul>
-        <li>Added PCGALERKIN and PCGalerkinSetRestriction/Interpolation() to allow easy creating of Galerkin-like preconditioners. </li>
-
-       <li> Added PCGetOperatorsSet() </li>
-
-       <li> Added support for the KSP/PC to auto-create the Mat(s) for you. (Which you usally set with KSP/PCSetOperators()). See manual page for
-            KSP/PCGetOperators(). Note this is slightly speculative code currently. </li>
-
-       <li> PCSetOperators()/KSPSetOperators() now do reference counting on the operators you pass in. Current usage will work, however this means you NO LONGER
-            need to keep a reference to the operators around until the KSP/PC object is destroyed.  </li>
-
+        <li>Added PCGALERKIN and
+PCGalerkinSetRestriction/Interpolation() to allow easy creating of
+Galerkin-like preconditioners. </li>
+        <li> Added PCGetOperatorsSet() </li>
+        <li> Added support for the KSP/PC to auto-create the Mat(s) for
+you. (Which you usally set with KSP/PCSetOperators()). See manual page
+for KSP/PCGetOperators(). Note this is slightly speculative code
+currently. </li>
+        <li> PCSetOperators()/KSPSetOperators() now do reference
+counting on the operators you pass in. Current usage will work, however
+this means you NO LONGER need to keep a reference to the operators
+around until the KSP/PC object is destroyed. </li>
       </ul>
-
-
-
-      
-      
       <ul>
-
-
-      
-      
       </ul>
-
-
-
-      
-      
       <p><u><b>KSP:</b></u><br>
-
       </p>
-
-
-      
-      
-      
       <ul>
-
-       <li>Added KSPDefaultConvergedSetUIRNorm() and -ksp_default_converged_initial_residual_norm to go back to the
-      pre PETSc 2.3.1 of determing relative tolerance for convergence. </li>
-      
-       <li> Added KSPGetOperatorsSet() </li>
-      
+        <li>Added KSPDefaultConvergedSetUIRNorm() and
+-ksp_default_converged_initial_residual_norm to go back to the pre
+PETSc 2.3.1 of determing relative tolerance for convergence. </li>
+        <li> Added KSPGetOperatorsSet() </li>
       </ul>
-
-
-
-      
-      
-      <p><u><b>config/configure.py:</b></u><br>
-
-      </p>
-
-
-
-      
-      
+      <p><u><b>config/configure.py:<br>
+      </b></u></p>
+      <ul>
+        <li>&nbsp;Now c++ complex version requires the options'
+'--with-scalar-type=complex --with-clanguage=cxx'. Specyfing only '--with-scalar-type=complex'
+will default to '--with-clanguage=c'&nbsp; i.e uses C99 complex support.<br>
+        </li>
+      </ul>
+      <p> </p>
       <ul>
-
-
-      
-      
       </ul>
-
-
-
-      
-      
       <p><u><b>SNES:</b></u></p>
-
-      
       <ul>
-
         <li>The convergence test functions for SNES now pass the
 current iteration in as the second argument. Also the convergence test
 routine is called after the initial function evaluation in SNES but
 before the first Newton step is computed. </li>
-
         <li>Added SNESSetKSP(). </li>
-
-      
       </ul>
-
-
-
-      
-      
       <ul>
-
-
-      
-      
       </ul>
-
-
-
-      
-      
       <p><u><b>TS:</b></u><br>
-
       </p>
-
-
-      
-      
-      
       <ul>
-
-
-      
-      
       </ul>
-
-
-      
-      
-      
       <p><u><b>DA:</b></u><br>
-
       </p>
-
-
-
-      
-      
       <ul>
-
-
-      
-      
       </ul>
-
-
-
-      
-      
       <p><u><b>DMMG:</b></u><br>
-
       </p>
-
-
-
-      
-      
       <ul>
-
-
-      
-      
       </ul>
-
-
-      
-      
-      
       <p><u><b>SYS:</b></u><br>
-
       </p>
-
-
-
-      
-      
       <ul>
-
-Removed PetscRandomType from the prototype of PetscRandomCreate().
-Added PetscRandomSetType(), PetscRandomGetValueReal() and
-PetscRandomGetValueImaginary(). Replaced RANDOM_DEFAULT,
+        <li>Removed PetscRandomType from the prototype of
+PetscRandomCreate(). <br>
+        </li>
+        <li>Added PetscRandomSetType(), PetscRandomGetValueReal() and
+PetscRandomGetValueImaginary(). <br>
+        </li>
+        <li>Replaced RANDOM_DEFAULT,
 RANDOM_DEFAULT_REAL and RANDOM_DEFAULT_IMAGINARY, the type of random
-numbers, with PETSCRAND48, PETSCRAND etc.
-      
+numbers, with PETSCRAND48, PETSCRAND etc.<br>
+        </li>
+      </ul>
+      <p><u><b>AO:</b></u></p>
+      <ul>
+        <li>AODATA object and associated routines are now depricated
+and scheduled for future removal</li>
       </ul>
-
-
-      
-      
-      
       <p><u><b>Fortran:</b></u><br>
-
       </p>
-
-
-
-      
-      
       <ul>
-
-
-      
-      
       </ul>
-
-
-      
-      
-      
-      <p><u><b><a href="http:/www-unix.mcs.anl.gov/petsc/petsc-as/miscellaneous/external.html">ExternalPackages</a>:</b></u><br>
-
+      <p><u><b><a
+ href="http:/www-unix.mcs.anl.gov/petsc/petsc-as/miscellaneous/external.html">ExternalPackages</a>:</b></u><br>
       </p>
-
-
-      
-      
-      
       <ul>
-
 SPRNG support added.
-      
-      
       </ul>
-
-
-
       <br>
-
-
-
       </td>
-
-
-
     </tr>
-
-
-
     <tr>
-
-
-
       <td colspan="2" width="100%">
-      
-      
-      
       <hr color="#ff5b5b" size="4"> </td>
-
-
-
     </tr>
-
-
-
-  
-  
-  
   </tbody>
 </table>
-
-
-
 </body>
 </html>

src/ksp/pc/impls/factor/cholesky/cholesky.c

     MatInfo info;
     if (!pc->setupcalled) {
       ierr = MatGetOrdering(pc->pmat,dir->ordering,&dir->row,&dir->col);CHKERRQ(ierr);
-      if (dir->col && (dir->row != dir->col)) {  /* only use row ordering for SBAIJ */
-        ierr = ISDestroy(dir->col);CHKERRQ(ierr); 
-        dir->col=0; 
-      }
+      /* check if dir->row == dir->col */
+      ierr = ISEqual(dir->row,dir->col,&flg);CHKERRQ(ierr);
+      if (!flg) SETERRQ(PETSC_ERR_ARG_INCOMP,"row and column permutations must equal");
+      ierr = ISDestroy(dir->col);CHKERRQ(ierr); /* only pass one ordering into CholeskyFactor */
+      dir->col=0; 
+
       ierr = PetscOptionsHasName(pc->prefix,"-pc_factor_nonzeros_along_diagonal",&flg);CHKERRQ(ierr);
       if (flg) {
         PetscReal tol = 1.e-10;

src/mat/impls/aij/seq/aijfact.c

   Mat            C = *B;
   Mat_SeqAIJ     *a=(Mat_SeqAIJ*)A->data;
   Mat_SeqSBAIJ   *b=(Mat_SeqSBAIJ*)C->data;
-  IS             ip=b->row;
+  IS             ip=b->row,iip = b->icol;
   PetscErrorCode ierr;
-  PetscInt       *rip,i,j,mbs=A->rmap.n,*bi=b->i,*bj=b->j,*bcol;
+  PetscInt       *rip,*riip,i,j,mbs=A->rmap.n,*bi=b->i,*bj=b->j,*bcol;
   PetscInt       *ai=a->i,*aj=a->j;
   PetscInt       k,jmin,jmax,*jl,*il,col,nexti,ili,nz;
   MatScalar      *rtmp,*ba=b->a,*bval,*aa=a->a,dk,uikdi;
   zeropivot = info->zeropivot; 
 
   ierr  = ISGetIndices(ip,&rip);CHKERRQ(ierr);
+  ierr  = ISGetIndices(iip,&riip);CHKERRQ(ierr);
   
   /* initialization */
   nz   = (2*mbs+1)*sizeof(PetscInt)+mbs*sizeof(MatScalar);
       /* initialize k-th row by the perm[k]-th row of A */
       jmin = ai[rip[k]]; jmax = ai[rip[k]+1];
       for (j = jmin; j < jmax; j++){
-        col = rip[aj[j]];
+        col = riip[aj[j]];
         if (col >= k){ /* only take upper triangular entry */
           rtmp[col] = aa[j];
           *bval++  = 0.0; /* for in-place factorization */
   ierr = PetscFree(il);CHKERRQ(ierr);
 
   ierr = ISRestoreIndices(ip,&rip);CHKERRQ(ierr);
+  ierr = ISRestoreIndices(iip,&riip);CHKERRQ(ierr);
   C->factor       = FACTOR_CHOLESKY; 
   C->assembled    = PETSC_TRUE; 
   C->preallocated = PETSC_TRUE;
 
   PetscFunctionBegin;
   /* check whether perm is the identity mapping */
-  ierr = ISIdentity(perm,&perm_identity);CHKERRQ(ierr);
+  ierr = ISIdentity(perm,&perm_identity);CHKERRQ(ierr);  
+  ierr = ISInvertPermutation(perm,PETSC_DECIDE,&iperm);CHKERRQ(ierr);
+  ierr = ISGetIndices(iperm,&riip);CHKERRQ(ierr);  
   ierr = ISGetIndices(perm,&rip);CHKERRQ(ierr);
 
-  if (!perm_identity){
-    /* check if perm is symmetric! */
-    ierr = ISInvertPermutation(perm,PETSC_DECIDE,&iperm);CHKERRQ(ierr);  
-    ierr = ISGetIndices(iperm,&riip);CHKERRQ(ierr);
-    for (i=0; i<am; i++) {
-      if (rip[i] != riip[i]) SETERRQ(PETSC_ERR_ARG_INCOMP,"Non-symmetric permutation, must use symmetric permutation");
-    }
-    ierr = ISRestoreIndices(iperm,&riip);CHKERRQ(ierr);
-    ierr = ISDestroy(iperm);CHKERRQ(ierr);
-  } 
-
   /* initialization */
   ierr  = PetscMalloc((am+1)*sizeof(PetscInt),&ui);CHKERRQ(ierr);
   ui[0] = 0; 
     /* initialize lnk by the column indices of row rip[k] of A */
     nzk   = 0;
     ncols = ai[rip[k]+1] - ai[rip[k]]; 
+    if (!ncols) SETERRQ(PETSC_ERR_MAT_CH_ZRPVT,"Empty row in matrix");
     ncols_upper = 0;
     for (j=0; j<ncols; j++){
-      i = rip[*(aj + ai[rip[k]] + j)];
+      i = riip[*(aj + ai[rip[k]] + j)];  
       if (i >= k){ /* only take upper triangular entry */
         cols[ncols_upper] = i;
         ncols_upper++;
 #endif
 
   ierr = ISRestoreIndices(perm,&rip);CHKERRQ(ierr);
+  ierr = ISRestoreIndices(iperm,&riip);CHKERRQ(ierr);
   ierr = PetscFree(jl);CHKERRQ(ierr);
 
   /* destroy list of free space and other temporary array(s) */
   b->ilen = 0;
   b->imax = 0;
   b->row  = perm;
-  b->pivotinblocks = PETSC_FALSE; /* need to get from MatFactorInfo */
+  b->col  = perm;
   ierr    = PetscObjectReference((PetscObject)perm);CHKERRQ(ierr); 
-  b->icol = perm;
   ierr    = PetscObjectReference((PetscObject)perm);CHKERRQ(ierr); 
+  b->icol = iperm;
+  b->pivotinblocks = PETSC_FALSE; /* need to get from MatFactorInfo */
   ierr    = PetscMalloc((am+1)*sizeof(PetscScalar),&b->solve_work);CHKERRQ(ierr);
   ierr    = PetscLogObjectMemory(B,(ui[am]-am)*(sizeof(PetscInt)+sizeof(MatScalar)));CHKERRQ(ierr);
   b->maxnz = b->nz = ui[am];

src/mat/impls/sbaij/seq/sbaij.c

   PetscLogObjectState((PetscObject)A,"Rows=%D, NZ=%D",A->rmap.N,a->nz);
 #endif
   ierr = MatSeqXAIJFreeAIJ(A,&a->a,&a->j,&a->i);CHKERRQ(ierr);
-  if (a->row) {
-    ierr = ISDestroy(a->row);CHKERRQ(ierr);
-  }
+  if (a->row) {ierr = ISDestroy(a->row);CHKERRQ(ierr);}
+  if (a->col){ierr = ISDestroy(a->col);CHKERRQ(ierr);}
+  if (a->icol) {ierr = ISDestroy(a->icol);CHKERRQ(ierr);}
   ierr = PetscFree(a->diag);CHKERRQ(ierr);
   ierr = PetscFree2(a->imax,a->ilen);CHKERRQ(ierr);
-  if (a->icol) {ierr = ISDestroy(a->icol);CHKERRQ(ierr);}
   ierr = PetscFree(a->solve_work);CHKERRQ(ierr);
   ierr = PetscFree(a->relax_work);CHKERRQ(ierr);
   ierr = PetscFree(a->solves_work);CHKERRQ(ierr);

src/tops/server/cxx/TOPS_StructuredSolver_Impl.cxx

 }
 
 /**
- * Method:  setValue[]
- */
-void
-TOPS::StructuredSolver_impl::setValue_impl (
-  /* in */const ::std::string& key,
-  /* in */const ::std::string& value ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.StructuredSolver.setValue)
-  // Insert-Code-Here {TOPS.StructuredSolver.setValue} (setValue method)
-  // DO-NOT-DELETE splicer.end(TOPS.StructuredSolver.setValue)
-}
-
-/**
- * Method:  setValue[Int]
- */
-void
-TOPS::StructuredSolver_impl::setValue_impl (
-  /* in */const ::std::string& key,
-  /* in */int32_t value ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.StructuredSolver.setValueInt)
-  // Insert-Code-Here {TOPS.StructuredSolver.setValueInt} (setValue method)
-  // DO-NOT-DELETE splicer.end(TOPS.StructuredSolver.setValueInt)
-}
-
-/**
- * Method:  setValue[Bool]
- */
-void
-TOPS::StructuredSolver_impl::setValue_impl (
-  /* in */const ::std::string& key,
-  /* in */bool value ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.StructuredSolver.setValueBool)
-  // Insert-Code-Here {TOPS.StructuredSolver.setValueBool} (setValue method)
-  // DO-NOT-DELETE splicer.end(TOPS.StructuredSolver.setValueBool)
-}
-
-/**
- * Method:  setValue[Double]
- */
-void
-TOPS::StructuredSolver_impl::setValue_impl (
-  /* in */const ::std::string& key,
-  /* in */double value ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.StructuredSolver.setValueDouble)
-  // Insert-Code-Here {TOPS.StructuredSolver.setValueDouble} (setValue method)
-  // DO-NOT-DELETE splicer.end(TOPS.StructuredSolver.setValueDouble)
-}
-
-/**
- * Method:  getValue[]
- */
-::std::string
-TOPS::StructuredSolver_impl::getValue_impl (
-  /* in */const ::std::string& key ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.StructuredSolver.getValue)
-  // Insert-Code-Here {TOPS.StructuredSolver.getValue} (getValue method)
-  return ""; // temporary default implementation to prevent compiler warnings
-  // DO-NOT-DELETE splicer.end(TOPS.StructuredSolver.getValue)
-}
-
-/**
- * Method:  getValueInt[]
- */
-int32_t
-TOPS::StructuredSolver_impl::getValueInt_impl (
-  /* in */const ::std::string& key ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.StructuredSolver.getValueInt)
-  // Insert-Code-Here {TOPS.StructuredSolver.getValueInt} (getValueInt method)
-    return 0; // temporary default implementation to prevent compiler warnings
-  // DO-NOT-DELETE splicer.end(TOPS.StructuredSolver.getValueInt)
-}
-
-/**
- * Method:  getValueBool[]
- */
-bool
-TOPS::StructuredSolver_impl::getValueBool_impl (
-  /* in */const ::std::string& key ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.StructuredSolver.getValueBool)
-  // Insert-Code-Here {TOPS.StructuredSolver.getValueBool} (getValueBool method)
-  return false; // temporary default implementation to prevent compiler warnings
-  // DO-NOT-DELETE splicer.end(TOPS.StructuredSolver.getValueBool)
-}
-
-/**
- * Method:  getValueDouble[]
- */
-double
-TOPS::StructuredSolver_impl::getValueDouble_impl (
-  /* in */const ::std::string& key ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.StructuredSolver.getValueDouble)
-  // Insert-Code-Here {TOPS.StructuredSolver.getValueDouble} (getValueDouble method)
-  return 0.0; // temporary default implementation to prevent compiler warnings
-  // DO-NOT-DELETE splicer.end(TOPS.StructuredSolver.getValueDouble)
-}
-
-/**
  *  Starts up a component presence in the calling framework.
  * @param services the component instance's handle on the framework world.
  * Contracts concerning Svc and setServices:

src/tops/server/cxx/TOPS_StructuredSolver_Impl.hxx

     )
     ;
 
-    /**
-     * user defined non-static method.
-     */
-    void
-    setValue_impl (
-      /* in */const ::std::string& key,
-      /* in */const ::std::string& value
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    void
-    setValue_impl (
-      /* in */const ::std::string& key,
-      /* in */int32_t value
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    void
-    setValue_impl (
-      /* in */const ::std::string& key,
-      /* in */bool value
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    void
-    setValue_impl (
-      /* in */const ::std::string& key,
-      /* in */double value
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    ::std::string
-    getValue_impl (
-      /* in */const ::std::string& key
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    int32_t
-    getValueInt_impl (
-      /* in */const ::std::string& key
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    bool
-    getValueBool_impl (
-      /* in */const ::std::string& key
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    double
-    getValueDouble_impl (
-      /* in */const ::std::string& key
-    )
-    ;
-
 
     /**
      *  Starts up a component presence in the calling framework.

src/tops/server/cxx/TOPS_UnstructuredSolver_Impl.cxx

 }
 
 /**
- * Method:  setValue[]
- */
-void
-TOPS::UnstructuredSolver_impl::setValue_impl (
-  /* in */const ::std::string& key,
-  /* in */const ::std::string& value ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.UnstructuredSolver.setValue)
-  // Insert-Code-Here {TOPS.UnstructuredSolver.setValue} (setValue method)
-  // DO-NOT-DELETE splicer.end(TOPS.UnstructuredSolver.setValue)
-}
-
-/**
- * Method:  setValue[Int]
- */
-void
-TOPS::UnstructuredSolver_impl::setValue_impl (
-  /* in */const ::std::string& key,
-  /* in */int32_t value ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.UnstructuredSolver.setValueInt)
-  // Insert-Code-Here {TOPS.UnstructuredSolver.setValueInt} (setValue method)
-  // DO-NOT-DELETE splicer.end(TOPS.UnstructuredSolver.setValueInt)
-}
-
-/**
- * Method:  setValue[Bool]
- */
-void
-TOPS::UnstructuredSolver_impl::setValue_impl (
-  /* in */const ::std::string& key,
-  /* in */bool value ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.UnstructuredSolver.setValueBool)
-  // Insert-Code-Here {TOPS.UnstructuredSolver.setValueBool} (setValue method)
-  // DO-NOT-DELETE splicer.end(TOPS.UnstructuredSolver.setValueBool)
-}
-
-/**
- * Method:  setValue[Double]
- */
-void
-TOPS::UnstructuredSolver_impl::setValue_impl (
-  /* in */const ::std::string& key,
-  /* in */double value ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.UnstructuredSolver.setValueDouble)
-  // Insert-Code-Here {TOPS.UnstructuredSolver.setValueDouble} (setValue method)
-  // DO-NOT-DELETE splicer.end(TOPS.UnstructuredSolver.setValueDouble)
-}
-
-/**
- * Method:  getValue[]
- */
-::std::string
-TOPS::UnstructuredSolver_impl::getValue_impl (
-  /* in */const ::std::string& key ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.UnstructuredSolver.getValue)
-  // Insert-Code-Here {TOPS.UnstructuredSolver.getValue} (getValue method)
-  return ""; // temporary default implementation to prevent compiler warnings
-  // DO-NOT-DELETE splicer.end(TOPS.UnstructuredSolver.getValue)
-}
-
-/**
- * Method:  getValueInt[]
- */
-int32_t
-TOPS::UnstructuredSolver_impl::getValueInt_impl (
-  /* in */const ::std::string& key ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.UnstructuredSolver.getValueInt)
-  // Insert-Code-Here {TOPS.UnstructuredSolver.getValueInt} (getValueInt method)
-  return 0; // temporary default implementation to prevent compiler warnings
-  // DO-NOT-DELETE splicer.end(TOPS.UnstructuredSolver.getValueInt)
-}
-
-/**
- * Method:  getValueBool[]
- */
-bool
-TOPS::UnstructuredSolver_impl::getValueBool_impl (
-  /* in */const ::std::string& key ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.UnstructuredSolver.getValueBool)
-  // Insert-Code-Here {TOPS.UnstructuredSolver.getValueBool} (getValueBool method)
-  return false; // temporary default implementation to prevent compiler warnings
-  // DO-NOT-DELETE splicer.end(TOPS.UnstructuredSolver.getValueBool)
-}
-
-/**
- * Method:  getValueDouble[]
- */
-double
-TOPS::UnstructuredSolver_impl::getValueDouble_impl (
-  /* in */const ::std::string& key ) 
-{
-  // DO-NOT-DELETE splicer.begin(TOPS.UnstructuredSolver.getValueDouble)
-  // Insert-Code-Here {TOPS.UnstructuredSolver.getValueDouble} (getValueDouble method)
-  return 0.0; // temporary default implementation to prevent compiler warnings
-  // DO-NOT-DELETE splicer.end(TOPS.UnstructuredSolver.getValueDouble)
-}
-
-/**
  *  Starts up a component presence in the calling framework.
  * @param services the component instance's handle on the framework world.
  * Contracts concerning Svc and setServices:

src/tops/server/cxx/TOPS_UnstructuredSolver_Impl.hxx

     )
     ;
 
-    /**
-     * user defined non-static method.
-     */
-    void
-    setValue_impl (
-      /* in */const ::std::string& key,
-      /* in */const ::std::string& value
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    void
-    setValue_impl (
-      /* in */const ::std::string& key,
-      /* in */int32_t value
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    void
-    setValue_impl (
-      /* in */const ::std::string& key,
-      /* in */bool value
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    void
-    setValue_impl (
-      /* in */const ::std::string& key,
-      /* in */double value
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    ::std::string
-    getValue_impl (
-      /* in */const ::std::string& key
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    int32_t
-    getValueInt_impl (
-      /* in */const ::std::string& key
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    bool
-    getValueBool_impl (
-      /* in */const ::std::string& key
-    )
-    ;
-
-    /**
-     * user defined non-static method.
-     */
-    double
-    getValueDouble_impl (
-      /* in */const ::std::string& key
-    )
-    ;
-
 
     /**
      *  Starts up a component presence in the calling framework.

src/tops/tops.sidl

       array<double> getSolution();
       void          setSolution(in array<double> location);
 
-      // Allows setting/accessing solver parameters
-      void   setValue(in string key, in string value);
-      void   setValue[Int](in string key, in int value);
-      void   setValue[Bool](in string key, in bool value);
-      void   setValue[Double](in string key, in double value);
-      string getValue(in string key);
-      int    getValueInt(in string key);
-      bool   getValueBool(in string key);
-      double getValueDouble(in string key);
   }
 
   // Interfaces inherited by the user to define the algebraic problem