Ejemplo n.º 1
0
void object::test<3>()
{
    Keyed one("one"), two("two"), three("three");
    // We don't want to rely on the underlying container delivering keys
    // in any particular order. That allows us the flexibility to
    // reimplement LLInstanceTracker using, say, a hash map instead of a
    // std::map. We DO insist that every key appear exactly once.
    typedef std::vector<std::string> StringVector;
    StringVector keys(Keyed::beginKeys(), Keyed::endKeys());
    std::sort(keys.begin(), keys.end());
    StringVector::const_iterator ki(keys.begin());
    ensure_equals(*ki++, "one");
    ensure_equals(*ki++, "three");
    ensure_equals(*ki++, "two");
    // Use ensure() here because ensure_equals would want to display
    // mismatched values, and frankly that wouldn't help much.
    ensure("didn't reach end", ki == keys.end());

    // Use a somewhat different approach to order independence with
    // beginInstances(): explicitly capture the instances we know in a
    // set, and delete them as we iterate through.
    typedef std::set<Keyed*> InstanceSet;
    InstanceSet instances;
    instances.insert(&one);
    instances.insert(&two);
    instances.insert(&three);
    for (Keyed::instance_iter ii(Keyed::beginInstances()), iend(Keyed::endInstances());
            ii != iend; ++ii)
    {
        Keyed& ref = *ii;
        ensure_equals("spurious instance", instances.erase(&ref), 1);
    }
    ensure_equals("unreported instance", instances.size(), 0);
}
Ejemplo n.º 2
0
  bool Model::
  computeJacobian(taoDNode const * node,
		  double gx, double gy, double gz,
		  Matrix & jacobian) const
  {
    if ( ! node) {
      return false;
    }
    ancestry_table_t::const_iterator iae(ancestry_table_.find(const_cast<taoDNode*>(node)));
    if (iae == ancestry_table_.end()) {
      return false;
    }
    ancestry_list_t const & alist(iae->second);
    
#ifdef DEBUG
    fprintf(stderr, "computeJacobian()\ng: [% 4.2f % 4.2f % 4.2f]\n", gx, gy, gz);
#endif // DEBUG
    
    // \todo Implement support for more than one joint per node, and
    // 	more than one DOF per joint.
    jacobian = Matrix::Zero(6, ndof_);
    ancestry_list_t::const_iterator ia(alist.begin());
    ancestry_list_t::const_iterator iend(alist.end());
    for (/**/; ia != iend; ++ia) {
      deVector6 Jg_col;
      ia->joint->getJgColumns(&Jg_col);
      int const icol(ia->id);
      
#ifdef DEBUG
      fprintf(stderr, "iJg[%d]: [ % 4.2f % 4.2f % 4.2f % 4.2f % 4.2f % 4.2f]\n",
	      icol,
	      Jg_col.elementAt(0), Jg_col.elementAt(1), Jg_col.elementAt(2),
	      Jg_col.elementAt(3), Jg_col.elementAt(4), Jg_col.elementAt(5));
#endif // DEBUG
      
      for (size_t irow(0); irow < 6; ++irow) {
	jacobian.coeffRef(irow, icol) = Jg_col.elementAt(irow);
      }
      
      // Add the effect of the joint rotation on the translational
      // velocity at the global point (column-wise cross product with
      // [gx;gy;gz]). Note that Jg_col.elementAt(3) is the
      // contribution to omega_x etc, because the upper 3 elements of
      // Jg_col are v_x etc.  (And don't ask me why we have to
      // subtract the cross product, it probably got inverted
      // somewhere)
      jacobian.coeffRef(0, icol) -= -gz * Jg_col.elementAt(4) + gy * Jg_col.elementAt(5);
      jacobian.coeffRef(1, icol) -=  gz * Jg_col.elementAt(3) - gx * Jg_col.elementAt(5);
      jacobian.coeffRef(2, icol) -= -gy * Jg_col.elementAt(3) + gx * Jg_col.elementAt(4);
      
#ifdef DEBUG
      fprintf(stderr, "0Jg[%d]: [ % 4.2f % 4.2f % 4.2f % 4.2f % 4.2f % 4.2f]\n",
	      icol,
	      jacobian.coeff(0, icol), jacobian.coeff(1, icol), jacobian.coeff(2, icol),
	      jacobian.coeff(3, icol), jacobian.coeff(4, icol), jacobian.coeff(5, icol));
#endif // DEBUG
      
    }
    return true;
  }
Ejemplo n.º 3
0
 bool Model::
 getGravity(Vector & gravity) const
 {
   if (0 == g_torque_.size()) {
     return false;
   }
   gravity = g_torque_;
   // knock away gravity torque from links that are already otherwise compensated
   dof_set_t::const_iterator iend(gravity_disabled_.end());
   for (dof_set_t::const_iterator ii(gravity_disabled_.begin()); ii != iend; ++ii) {
     gravity[*ii] = 0;
   }
   return true;
 }
Ejemplo n.º 4
0
void object::test<4>()
{
    Unkeyed one, two, three;
    typedef std::set<Unkeyed*> KeySet;

    KeySet instances;
    instances.insert(&one);
    instances.insert(&two);
    instances.insert(&three);

    for (Unkeyed::instance_iter ii(Unkeyed::beginInstances()), iend(Unkeyed::endInstances()); ii != iend; ++ii)
    {
        Unkeyed& ref = *ii;
        ensure_equals("spurious instance", instances.erase(&ref), 1);
    }

    ensure_equals("unreported instance", instances.size(), 0);
}
Ejemplo n.º 5
0
void
Elastic::FAC::pack_v_v_rhs(double* buffer,
                           const SAMRAI::hier::Patch& patch,
                           const SAMRAI::hier::Box& region,
                           const std::string& variable_name,
                           const int &depth) const
{
  boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_ptr;
  if (variable_name == "Displacement") {
    v_ptr = boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
      (patch.getPatchData(v_id));
  }
  else if ("Fault Correction + RHS" == variable_name)
    {
      v_ptr = boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
        (patch.getPatchData(v_rhs_id));
    }
  else
    {
      TBOX_ERROR("Unregistered variable name '" << variable_name << "' in\n"
                 << "Elastic::FAC::packDerivedDataIntoDoubleBuffer");
    }

  SAMRAI::pdat::SideData<double>& v = *v_ptr;
  if(d_dim.getValue()==2)
    {
      const SAMRAI::hier::Index ip(1,0), jp(0,1);

      SAMRAI::pdat::CellIterator iend(SAMRAI::pdat::CellGeometry::end(region));
      for (SAMRAI::pdat::CellIterator
             icell(SAMRAI::pdat::CellGeometry::begin(region));
           icell!=iend; ++icell)
        {

          const SAMRAI::pdat::CellIndex &center(*icell);
          const SAMRAI::pdat::SideIndex
            x(center,0,SAMRAI::pdat::SideIndex::Lower),
            y(center,1,SAMRAI::pdat::SideIndex::Lower);
	
          double vx=v(x);
          double vy=v(y);

          if(!offset_vector_on_output)
            {
              vx=(v(x+ip) + vx)/2;
              vy=(v(y+jp) + vy)/2;
            }

          if (0==depth)
            {
              *buffer = vx;
            }
          else
            {
              *buffer = vy;
            }
          buffer = buffer + 1;
        }
    }
  else
    {
      const SAMRAI::hier::Index ip(1,0,0), jp(0,1,0), kp(0,0,1);
      SAMRAI::pdat::CellIterator iend(SAMRAI::pdat::CellGeometry::end(region));
      for (SAMRAI::pdat::CellIterator
             icell(SAMRAI::pdat::CellGeometry::begin(region));
           icell!=iend; ++icell)
        {

          const SAMRAI::pdat::CellIndex &center(*icell);
          const SAMRAI::pdat::SideIndex
            x(center,0,SAMRAI::pdat::SideIndex::Lower),
            y(center,1,SAMRAI::pdat::SideIndex::Lower),
            z(center,2,SAMRAI::pdat::SideIndex::Lower);
	
          double vx=v(x);
          double vy=v(y);
          double vz=v(z);

          if(!offset_vector_on_output)
            {
              vx=(v(x+ip) + vx)/2;
              vy=(v(y+jp) + vy)/2;
              vz=(v(z+kp) + vz)/2;
            }

          if (0==depth)
            {
              *buffer = vx;
            }
          else if (1==depth)
            {
              *buffer = vy;
            }
          else
            {
              *buffer = vz;
            }
          ++buffer;
        }
    }
}
void DenseDescriptorDictionaryTrainer::parseImage()
{
	//online dictionary builder
	OnlineDictionary online_dictionary(m_dictionary_capacity);
	
	std::map<std::string,std::string> samples_and_annotation;
	std::map<std::string,Array<int,4>> samples_regions;
	std::map<std::string,int> samples_labels;
	int labels_num;

	//load samples from file
	loadObjectClassifyTrainingSamples(samples_and_annotation,samples_regions,samples_labels,labels_num);

	ImageReadNode<ImageSignal<float>> img_read;
	ImageReadNode<ImageSignal<unsigned char>> lable_read;
	std::map<std::string,std::string>::iterator iter,iend(samples_and_annotation.end());
	for (iter = samples_and_annotation.begin(); iter != iend; ++iter)
	{
		std::string sample_file_name = iter->first;
		if (!sample_file_name.empty())
		{
			EAGLEEYE_INFO("process %s \n",sample_file_name.c_str());

			img_read.setFilePath((m_trainer_folder + sample_file_name).c_str());
			img_read.start();

			Matrix<float> img_sample = img_read.getImage();		
			Array<int,4> object_region = samples_regions[sample_file_name];

			Matrix<float> local_img_sample = img_sample(Range(object_region[2],object_region[3]),Range(object_region[0],object_region[1]));
			local_img_sample.clone();
			
//			putToMatlab(local_img_sample,"local_img");

			//resize img
			if (m_is_resize_flag)
			{
				local_img_sample = resize(local_img_sample,m_scales[0]);
			}
			
//			putToMatlab(local_img_sample,"resize_local_img");

			//get rid of noise 
			if (m_is_gaussian_flag)
			{
				local_img_sample = gaussFilter(local_img_sample,m_kernel_size[0],m_kernel_size[1]);
			}
//			putToMatlab(local_img_sample,"gaussian_local_img");

			//get dense points
			DenseFeatureDetector dense_feature_det;
			if (m_is_needed_main_dir)
			{
				dense_feature_det.enableCalcMainDir();
			}
			else
			{
				dense_feature_det.disableCalcMainDir();
			}

			dense_feature_det.setDetectorParams(m_init_scale,m_scale_levels,m_scale_mul,m_init_xy_step,m_init_img_bound,
				m_search_radius,m_vary_xy_step_with_scale,m_vary_img_bound_with_scale);

			std::vector<KeyPoint> keypoints;
			dense_feature_det.detect(local_img_sample,keypoints);

			//compute keypoint descriptors
			Matrix<float> keypoints_descripors;
			m_descriptor->compute(local_img_sample,keypoints,keypoints_descripors);

			online_dictionary.trainOnline(keypoints_descripors,m_dictionary,m_dictionary_counts);
		}
	}

	Dictionary::saveDictionary(m_dictionary,(m_trainer_folder + m_trainer_name + m_ext_name).c_str());
}
Ejemplo n.º 7
0
void
Elastic::FAC::pack_strain(double* buffer,
                          const SAMRAI::hier::Patch& patch,
                          const SAMRAI::hier::Box& region,
                          const int &depth) const
{
  boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_ptr=
    boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
    (patch.getPatchData(v_id));
  SAMRAI::pdat::SideData<double>& v = *v_ptr;

  boost::shared_ptr<SAMRAI::pdat::CellData<double> > dv_diagonal;
  boost::shared_ptr<SAMRAI::pdat::SideData<double> > dv_mixed;
  if(!faults.empty())
    {
      dv_diagonal=boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
        (patch.getPatchData(dv_diagonal_id));
      dv_mixed=boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
        (patch.getPatchData(dv_mixed_id));
    }

  const Gamra::Dir dim=d_dim.getValue();
  if(have_embedded_boundary())
    {
      boost::shared_ptr<SAMRAI::pdat::SideData<double> > level_set_ptr;
      if(have_embedded_boundary())
        level_set_ptr=boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
          (patch.getPatchData(level_set_id));
    }

  Gamra::Dir ix(Gamra::Dir::from_int(depth/dim)),
    iy(Gamra::Dir::from_int(depth%dim));
  const SAMRAI::hier::Index zero(SAMRAI::hier::Index::getZeroIndex(d_dim));
  SAMRAI::hier::Index ip(zero), jp(zero);
  ip[ix]=1;
  jp[iy]=1;

  const double *dx(boost::dynamic_pointer_cast
                   <SAMRAI::geom::CartesianPatchGeometry>
                   (patch.getPatchGeometry())->getDx());

  SAMRAI::pdat::CellIterator iend(SAMRAI::pdat::CellGeometry::end(region));
  for(SAMRAI::pdat::CellIterator
        icell(SAMRAI::pdat::CellGeometry::begin(region));
      icell!=iend; ++icell)
    {
      const SAMRAI::pdat::SideIndex
        s(*icell,ix,SAMRAI::pdat::SideIndex::Lower);
      if(ix==iy)
        {
          double diff(v(s+ip)-v(s));
          if(!faults.empty())
            diff-=(*dv_diagonal)(*icell,ix);
          *buffer=diff/dx[ix];
        }
      else
        {
          const int ix_iy(index_map(ix,iy,dim));
          double diff(- v(s-jp) - v(s+ip-jp) + v(s+jp)  + v(s+ip+jp));

          if(!faults.empty())
            diff+=(*dv_mixed)(s,ix_iy+1) - (*dv_mixed)(s-jp,ix_iy)
              + (*dv_mixed)(s+ip,ix_iy+1) - (*dv_mixed)(s+ip-jp,ix_iy)
              + (*dv_mixed)(s+jp,ix_iy+1) - (*dv_mixed)(s,ix_iy)
              + (*dv_mixed)(s+ip+jp,ix_iy+1) - (*dv_mixed)(s+ip,ix_iy);
          *buffer=diff/(4*dx[iy]);
        }
      ++buffer;
    }
}
BOOL LLFloaterAbout::postBuild()
{
	center();
	LLViewerTextEditor *support_widget = 
		getChild<LLViewerTextEditor>("support_editor", true);

	LLViewerTextEditor *credits_widget = 
		getChild<LLViewerTextEditor>("credits_editor", true);

	getChild<LLUICtrl>("copy_btn")->setCommitCallback(
		boost::bind(&LLFloaterAbout::onClickCopyToClipboard, this));

#if LL_WINDOWS
	getWindow()->incBusyCount();
	getWindow()->setCursor(UI_CURSOR_ARROW);
#endif
	LLSD info(getInfo());
#if LL_WINDOWS
	getWindow()->decBusyCount();
	getWindow()->setCursor(UI_CURSOR_ARROW);
#endif

	std::ostringstream support;

	// Render the LLSD from getInfo() as a format_map_t
	LLStringUtil::format_map_t args;

	// allow the "Release Notes" URL label to be localized
	args["ReleaseNotes"] = LLTrans::getString("ReleaseNotes");

	for (LLSD::map_const_iterator ii(info.beginMap()), iend(info.endMap());
		 ii != iend; ++ii)
	{
		if (! ii->second.isArray())
		{
			// Scalar value
			if (ii->second.isUndefined())
			{
				args[ii->first] = getString("none");
			}
			else
			{
				// don't forget to render value asString()
				args[ii->first] = ii->second.asString();
			}
		}
		else
		{
			// array value: build KEY_0, KEY_1 etc. entries
			for (LLSD::Integer n(0), size(ii->second.size()); n < size; ++n)
			{
				args[STRINGIZE(ii->first << '_' << n)] = ii->second[n].asString();
			}
		}
	}

	// Now build the various pieces
	support << getString("AboutHeader", args);
	if (info.has("REGION"))
	{
		support << "\n\n" << getString("AboutPosition", args);
	}
	support << "\n\n" << getString("AboutSystem", args);
	support << "\n";
	if (info.has("GRAPHICS_DRIVER_VERSION"))
	{
		support << "\n" << getString("AboutDriver", args);
	}
	support << "\n" << getString("AboutLibs", args);
	if (info.has("COMPILER"))
	{
		support << "\n" << getString("AboutCompiler", args);
	}
	if (info.has("PACKETS_IN"))
	{
		support << '\n' << getString("AboutTraffic", args);
	}

	support_widget->appendText(support.str(), 
								FALSE, 
								LLStyle::Params()
									.color(LLUIColorTable::instance().getColor("TextFgReadOnlyColor")));
	support_widget->blockUndo();

	// Fix views
	support_widget->setEnabled(FALSE);
	support_widget->startOfDoc();

	credits_widget->setEnabled(FALSE);
	credits_widget->startOfDoc();

	return TRUE;
}
Ejemplo n.º 9
0
  int Model::
  init(tao_tree_info_s * kgm_tree,
       tao_tree_info_s * cc_tree,
       std::ostream * msg)
  {
    int const status(tao_consistency_check(kgm_tree->root, msg));
    if (0 != status) {
      return status;
    }
    
    if (kgm_tree_) {
      if (msg) {
	*msg << "jspace::Model::init(): already initialized\n";
      }
      return -1;
    }
    
    if ( ! kgm_tree->sort()) {
      if (msg) {
	*msg << "jspace::Model::init(): could not sort KGM nodes according to IDs\n";
      }
      return -2;
    }
    
    if ((0 != cc_tree) && ( ! cc_tree->sort())) {
      if (msg) {
	*msg << "jspace::Model::init(): could not sort CC nodes according to IDs\n";
      }
      return -3;
    }
    
    // Create ancestry table of all nodes in the KGM tree, for correct
    // (and slightly more efficient) computation of the Jacobian.
    ancestry_table_.clear();	// just paranoid...
    typedef tao_tree_info_s::node_info_t::const_iterator cit_t;
    cit_t in(kgm_tree->info.begin());
    cit_t iend(kgm_tree->info.end());
    for (/**/; in != iend; ++in) {
      // ...paranoid checks...
      if ( ! in->node) {
	if (msg) {
	  *msg << "jspace::Model::init(): NULL node at entry #" << in->id << "\n";
	}
	return -4;
      }
      if (in->id != in->node->getID()) {
	if (msg) {
	  *msg << "jspace::Model::init(): node ID of entry #" << in->id << " is " << in->node->getID() << "\n";
	}
	return -5;
      }
      ancestry_list_t & alist(ancestry_table_[in->node]); // first reference creates the instance
      // walk up the ancestry, append each parent to the list of
      // ancestors of this node
      for (taoDNode * node(in->node); 0 != node; node = node->getDParent()) {
	ancestry_entry_s entry;
	entry.id = node->getID();
	entry.joint = node->getJointList();
	if (0 != entry.joint) {
	  alist.push_back(entry);
	}
      }
    }
    
    kgm_tree_ = kgm_tree;
    cc_tree_ = cc_tree;
    ndof_ = kgm_tree->info.size();
    
    return 0;
  }
Ejemplo n.º 10
0
ErrorCode DenseTag::find_entities_with_value( const SequenceManager* seqman,
                                              Error* error,
                                              Range& output_entities,
                                              const void* value,
                                              int value_bytes,
                                              EntityType type,
                                              const Range* intersect_entities ) const
{
  if (value_bytes && value_bytes != get_size()) {
    error->set_last_error( "Cannot compare data of size %d with tag of size %d",
                           value_bytes, get_size() );
    return MB_INVALID_SIZE;
  }

  if (!intersect_entities) {
    std::pair<EntityType,EntityType> range = type_range(type);
    TypeSequenceManager::const_iterator i;
    for (EntityType t = range.first; t != range.second; ++i) {
      const TypeSequenceManager& map = seqman->entity_map(t);
      for (i = map.begin(); i != map.end(); ++i) {
        const void* data = (*i)->data()->get_tag_data( mySequenceArray );
        if (data) {
          ByteArrayIterator start( (*i)->data()->start_handle(), data, *this );
          ByteArrayIterator end( (*i)->end_handle() + 1, 0, 0 );
          start += (*i)->start_handle() - (*i)->data()->start_handle();
          find_tag_values_equal( *this, value, get_size(), start, end, output_entities );
        }
      }
    }
  }
  else {
    const unsigned char* array = NULL; // initialize to get rid of warning
    size_t count;
    ErrorCode rval;
     
    Range::const_pair_iterator p = intersect_entities->begin();
    if (type != MBMAXTYPE) {
      p = intersect_entities->lower_bound(type);
      assert(TYPE_FROM_HANDLE(p->first) == type);
    }
    for (; 
         p != intersect_entities->const_pair_end() && 
         (MBMAXTYPE == type || TYPE_FROM_HANDLE(p->first) == type); 
         ++p) {

      EntityHandle start = p->first;
      while (start <= p->second) {
        rval = get_array( seqman, error, start, array, count );
        if (MB_SUCCESS != rval)
          return rval; 
        
        if (p->second - start < count-1)
          count = p->second - start + 1;
        
        if (array) {
          ByteArrayIterator istart( start, array, *this );
          ByteArrayIterator iend( start+count, 0, 0 );
          find_tag_values_equal( *this, value, get_size(), istart, iend, output_entities );
        }
        start += count;
      }
    }
  }    
  
  return MB_SUCCESS;
}
 /// ensures get_index() works properly after changing tokens vector or drop_get_index
 void generate_get_index()
 {
     for (index_type i=ibegin();i<iend();++i)
         dict_hash.insert(i);
 }
Ejemplo n.º 12
0
/*
*************************************************************************
* Set up the initial guess and problem parameters                       *
* and solve the Stokes problem.  We explicitly initialize and          *
* deallocate the solver state in this example.                          *
*************************************************************************
*/
bool Stokes::FAC::solve()
{

  if (!d_hierarchy) {
    TBOX_ERROR(d_object_name
               << "Cannot solve using an uninitialized object.\n");
  }

  int ln;
  /*
   * Fill in the initial guess.
   */
  for (ln = 0; ln <= d_hierarchy->getFinestLevelNumber(); ++ln) {
    boost::shared_ptr<SAMRAI::hier::PatchLevel> level = d_hierarchy->getPatchLevel(ln);
    SAMRAI::hier::PatchLevel::Iterator ip(level->begin());
    SAMRAI::hier::PatchLevel::Iterator iend(level->end());
    for ( ; ip!=iend; ++ip) {
      boost::shared_ptr<SAMRAI::hier::Patch> patch = *ip;
      boost::shared_ptr<SAMRAI::pdat::CellData<double> > p =
        boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
        (patch->getPatchData(p_id));

      boost::shared_ptr<SAMRAI::geom::CartesianPatchGeometry> geom =
        boost::dynamic_pointer_cast<SAMRAI::geom::CartesianPatchGeometry>
        (patch->getPatchGeometry());

      if(p_initial.empty())
        {
          p->fill(0.0);
        }
      else
        {
          const int dim=d_dim.getValue();
          const double *dx=geom->getDx();
          std::vector<double> xyz(dim);
          std::vector<double> dx_p(dim);
          for(int d=0;d<dim;++d)
            dx_p[d]=(p_initial_xyz_max[d]
                     - p_initial_xyz_min[d])/(p_initial_ijk[d]-1);
          std::vector<int> di(dim);
          di[0]=1;
          for(int d=1;d<dim;++d)
            di[d]=di[d-1]*p_initial_ijk[d-1];

          SAMRAI::hier::Box pbox = p->getBox();
          SAMRAI::pdat::CellIterator
            cend(SAMRAI::pdat::CellGeometry::end(p->getGhostBox()));
          for(SAMRAI::pdat::CellIterator
                ci(SAMRAI::pdat::CellGeometry::begin(p->getGhostBox()));
              ci!=cend; ++ci)
            {
              const SAMRAI::pdat::CellIndex &c(*ci);
              std::vector<double> xyz(dim);
              /* VLA's not allowed by clang */
              double weight[3][2];
              for(int d=0;d<dim;++d)
                xyz[d]=geom->getXLower()[d]
                  + dx[d]*(c[d]-pbox.lower()[d] + 0.5);

              int ijk(0);
              std::vector<int> ddi(dim);
              for(int d=0;d<dim;++d)
                {
                  int i=static_cast<int>(xyz[d]*(p_initial_ijk[d]-1)
                                         /(p_initial_xyz_max[d]
                                           - p_initial_xyz_min[d]));
                  i=std::max(0,std::min(p_initial_ijk[d]-1,i));
                  ijk+=i*di[d];

                  if(i==p_initial_ijk[d]-1)
                    {
                      weight[d][0]=1;
                      weight[d][1]=0;
                      ddi[d]=0;
                    }
                  else
                    {
                      weight[d][1]=
                        (xyz[d]-(i*dx_p[d] + p_initial_xyz_min[d]))/dx_p[d];
                      weight[d][0]=1-weight[d][1];
                      ddi[d]=di[d];
                    }
                }

              if(dim==2)
                {
                  (*p)(c)=p_initial[ijk]*weight[0][0]*weight[1][0]
                    + p_initial[ijk+ddi[0]]*weight[0][1]*weight[1][0]
                    + p_initial[ijk+ddi[1]]*weight[0][0]*weight[1][1]
                    + p_initial[ijk+ddi[0]+ddi[1]]*weight[0][1]*weight[1][1];
                }
              else
                {
                  (*p)(c)=p_initial[ijk]*weight[0][0]*weight[1][0]*weight[2][0]
                    + p_initial[ijk+ddi[0]]*weight[0][1]*weight[1][0]*weight[2][0]
                    + p_initial[ijk+ddi[1]]*weight[0][0]*weight[1][1]*weight[2][0]
                    + p_initial[ijk+ddi[0]+ddi[1]]*weight[0][1]*weight[1][1]*weight[2][0]
                    
                    + p_initial[ijk+ddi[2]]*weight[0][0]*weight[1][0]*weight[2][1]
                    + p_initial[ijk+ddi[0]+ddi[2]]*weight[0][1]*weight[1][0]*weight[2][1]
                    + p_initial[ijk+ddi[1]+ddi[2]]*weight[0][0]*weight[1][1]*weight[2][1]
                    + p_initial[ijk+ddi[0]+ddi[1]+ddi[2]]*weight[0][1]*weight[1][1]*weight[2][1];
                }
            }
        }

      boost::shared_ptr<SAMRAI::pdat::SideData<double> > v =
        boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
        (patch->getPatchData(v_id));
      v->fill(0.0);
    }
    d_stokes_fac_solver.set_boundaries(p_id,v_id,level,false);
  }

  fix_viscosity();

  d_stokes_fac_solver.initializeSolverState
    (p_id,cell_viscosity_id,edge_viscosity_id,dp_id,p_rhs_id,v_id,v_rhs_id,
     d_hierarchy,0,d_hierarchy->getFinestLevelNumber());

  SAMRAI::tbox::plog << "solving..." << std::endl;
  int solver_ret;
  solver_ret = d_stokes_fac_solver.solveSystem(p_id,p_rhs_id,v_id,v_rhs_id);

  double avg_factor, final_factor;
  d_stokes_fac_solver.getConvergenceFactors(avg_factor, final_factor);
  SAMRAI::tbox::plog << "\t" << (solver_ret ? "" : "NOT ") << "converged " << "\n"
             << "	iterations: "
             << d_stokes_fac_solver.getNumberOfIterations() << "\n"
             << "	residual: "<< d_stokes_fac_solver.getResidualNorm()
             << "\n"
             << "	average convergence: "<< avg_factor << "\n"
             << "	final convergence: "<< final_factor << "\n"
             << std::flush;

  d_stokes_fac_solver.deallocateSolverState();

  return solver_ret;
}