Exemplo n.º 1
0
boost::shared_ptr<SAMRAI::hier::PatchData> CleverSideDataFactory<TYPE>::allocate(
    const SAMRAI::hier::Patch& patch) const
{
  return boost::make_shared<CleverSideData<TYPE> >(
      patch.getBox(),
      d_depth,
      d_ghosts);
}
Exemplo n.º 2
0
void CleverNodeInjection<TYPE>::coarsen(
    SAMRAI::hier::Patch& coarse,
    const SAMRAI::hier::Patch& fine,
    const int dst_component,
    const int src_component,
    const SAMRAI::hier::Box& coarse_box,
    const SAMRAI::hier::IntVector& ratio) const
{
  boost::shared_ptr<CleverNodeData<TYPE> > fine_data(
      SHARED_PTR_CAST(CleverNodeData<TYPE> ,
        fine.getPatchData(src_component)));

  boost::shared_ptr<CleverNodeData<TYPE> > coarse_data(
      SHARED_PTR_CAST(CleverNodeData<TYPE> ,
        coarse.getPatchData(dst_component)));

  const SAMRAI::hier::Box coarse_ghost_box =
    SAMRAI::pdat::NodeGeometry::toNodeBox(coarse_data->getGhostBox());
  const SAMRAI::hier::Box fine_ghost_box = 
    SAMRAI::pdat::NodeGeometry::toNodeBox(fine_data->getGhostBox());

   const hier::Index filo = fine_data->getGhostBox().lower();
   const hier::Index fihi = fine_data->getGhostBox().upper();
   const hier::Index cilo = coarse_data->getGhostBox().lower();
   const hier::Index cihi = coarse_data->getGhostBox().upper();

   const hier::Index ifirstc = coarse_box.lower();
   const hier::Index ilastc = coarse_box.upper();

  for(int depth = 0; depth < coarse_data->getDepth(); depth++) {
    if (fine.getDim() == SAMRAI::tbox::Dimension(2)) {
         F90_FUNC(conavgclevernodedoub2d, CONAVGCLEVERNODEDOUB2D)
           (ifirstc(0), ifirstc(1), ilastc(0), ilastc(1),
            filo(0), filo(1), fihi(0), fihi(1),
            cilo(0), cilo(1), cihi(0), cihi(1),
            &ratio[0],
            fine_data->getPointer(depth),
            coarse_data->getPointer(depth));
    } else {
      TBOX_ERROR("CleverNodeInjection error...\n"
          << "dim != 2 not supported." << std::endl);
    }
  }
}
Exemplo n.º 3
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;
        }
    }
}
Exemplo n.º 4
0
void
Stokes::V_Coarsen_Patch_Strategy::postprocessCoarsen_2D
(SAMRAI::hier::Patch& coarse,
 const SAMRAI::hier::Patch& fine,
 const SAMRAI::hier::Box& ,
 const SAMRAI::hier::IntVector& )
{
  /* Fix up the boundary elements by iterating through the boundary
     boxes */

  /* We only care about edges, not corners, so we only iterate over
     edge boundary boxes. */
  const std::vector<SAMRAI::hier::BoundaryBox>
    &boundaries=coarse_fine[fine.getPatchLevelNumber()]->getEdgeBoundaries(coarse.getGlobalId());
     
  boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_fine =
    boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
    (fine.getPatchData(v_id));
  boost::shared_ptr<SAMRAI::pdat::SideData<double> > v =
    boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
    (coarse.getPatchData(v_id));

  TBOX_ASSERT(v);
  TBOX_ASSERT(v_fine);
  TBOX_ASSERT(v_fine->getDepth() == v->getDepth());
  TBOX_ASSERT(v->getDepth() == 1);

  SAMRAI::hier::Box gbox(v_fine->getGhostBox());
  SAMRAI::hier::Index ip(1,0), jp(0,1);
  for(size_t mm=0; mm<boundaries.size(); ++mm)
    {
      SAMRAI::hier::Box bbox=boundaries[mm].getBox();
      int location_index=boundaries[mm].getLocationIndex();

      SAMRAI::hier::Index
        lower=SAMRAI::hier::Index::coarsen(bbox.lower(),
                                           SAMRAI::hier::Index(2,2)),
        upper=SAMRAI::hier::Index::coarsen(bbox.upper(),
                                           SAMRAI::hier::Index(2,2));

      for(int j=lower(1); j<=upper(1); ++j)
        for(int i=lower(0); i<=upper(0); ++i)
          {
            /* Fix vx */
            if(location_index==0)
              {
                SAMRAI::pdat::SideIndex coarse(SAMRAI::hier::Index(i,j),0,
                                               SAMRAI::pdat::SideIndex::Upper);
                SAMRAI::pdat::SideIndex center(coarse*2);
                if(center[1]>=gbox.lower(1) && center[1]<gbox.upper(1))
                  {
                    (*v)(coarse)=((*v_fine)(center) + (*v_fine)(center+jp))/2;
                  }
              }
            else if(location_index==1)
              {
                SAMRAI::pdat::SideIndex coarse(SAMRAI::hier::Index(i,j),0,
                                               SAMRAI::pdat::SideIndex::Lower);
                SAMRAI::pdat::SideIndex center(coarse*2);
                if(center[1]>=gbox.lower(1) && center[1]<gbox.upper(1))
                  {
                    (*v)(coarse)=((*v_fine)(center) + (*v_fine)(center+jp))/2;
                  }
              }
            /* Fix vy */
            else if(location_index==2)
              {
                SAMRAI::pdat::SideIndex coarse(SAMRAI::hier::Index(i,j),1,
                                               SAMRAI::pdat::SideIndex::Upper);
                SAMRAI::pdat::SideIndex center(coarse*2);
                if(center[0]>=gbox.lower(0) && center[0]<gbox.upper(0))
                  {
                    (*v)(coarse)=((*v_fine)(center) + (*v_fine)(center+ip))/2;
                  }
              }
            else if(location_index==3)
              {
                SAMRAI::pdat::SideIndex coarse(SAMRAI::hier::Index(i,j),1,
                                               SAMRAI::pdat::SideIndex::Lower);
                SAMRAI::pdat::SideIndex center(coarse*2);
                if(center[0]>=gbox.lower(0) && center[0]<gbox.upper(0))
                  {
                    (*v)(coarse)=((*v_fine)(center) + (*v_fine)(center+ip))/2;
                  }
              }
            else
              {
                abort();
              }
          }
    }
}
Exemplo n.º 5
0
void Stokes::FACOps::residual_3D
(SAMRAI::pdat::CellData<double> &p,
 SAMRAI::pdat::SideData<double> &v,
 SAMRAI::pdat::CellData<double> &cell_viscosity,
 SAMRAI::pdat::CellData<double> &p_rhs,
 SAMRAI::pdat::SideData<double> &v_rhs,
 SAMRAI::pdat::CellData<double> &p_resid,
 SAMRAI::pdat::SideData<double> &v_resid,
 SAMRAI::hier::Patch &patch,
 const SAMRAI::hier::Box &pbox,
 const SAMRAI::geom::CartesianPatchGeometry &geom)
{
  boost::shared_ptr<SAMRAI::pdat::EdgeData<double> > edge_viscosity_ptr = 
    boost::dynamic_pointer_cast<SAMRAI::pdat::EdgeData<double> >
    (patch.getPatchData(edge_viscosity_id));
  SAMRAI::pdat::EdgeData<double> &edge_viscosity(*edge_viscosity_ptr);

  const double *Dx = geom.getDx();
  const SAMRAI::hier::Index ip(1,0,0), jp(0,1,0), kp(0,0,1);
  const SAMRAI::hier::Index pp[]={ip,jp,kp};

  SAMRAI::pdat::CellIterator cend(SAMRAI::pdat::CellGeometry::end(pbox));
  for(SAMRAI::pdat::CellIterator ci(SAMRAI::pdat::CellGeometry::begin(pbox));
      ci!=cend; ++ci)
    {
      const SAMRAI::pdat::CellIndex &center(*ci);
      SAMRAI::pdat::CellIndex up(center), down(center), right(center),
        left(center), front(center), back(center);

      ++right[0];
      --left[0];
      ++up[1];
      --down[1];
      ++front[2];
      --back[2];

      /* p */
      if(center[0]!=pbox.upper(0) && center[1]!=pbox.upper(1)
         && center[2]!=pbox.upper(2))
        {
          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 dvx_dx=(v(x+ip) - v(x))/Dx[0];
          double dvy_dy=(v(y+jp) - v(y))/Dx[1];
          double dvz_dz=(v(z+kp) - v(z))/Dx[2];
          p_resid(center)=p_rhs(center) - dvx_dx - dvy_dy - dvz_dz;
        }

      for(Gamra::Dir ix=0;ix<3;++ix)
        {
          const Gamra::Dir iy(ix.next(3));
          const Gamra::Dir iz(iy.next(3));
          const SAMRAI::pdat::SideIndex
            x(center,ix,SAMRAI::pdat::SideIndex::Lower),
            y(center,iy,SAMRAI::pdat::SideIndex::Lower),
            z(center,iz,SAMRAI::pdat::SideIndex::Lower);
          const SAMRAI::pdat::EdgeIndex
            edge_y(center,iy,SAMRAI::pdat::EdgeIndex::LowerLeft),
            edge_z(center,iz,SAMRAI::pdat::EdgeIndex::LowerLeft);

          if(center[iy]!=pbox.upper(iy) && center[iz]!=pbox.upper(iz))
            {
              if((center[ix]==pbox.lower(ix) && v(x-pp[ix])==boundary_value)
                 || (center[ix]==pbox.upper(ix) && v(x+pp[ix])==boundary_value))
                {
                  v_resid(x)=0;
                }
              else
                {
                  v_resid(x)=v_rhs(x)
                    - v_operator_3D(v,p,cell_viscosity,edge_viscosity,
                                    center,edge_y,edge_z,x,y,z,
                                    pp[ix],pp[iy],pp[iz],Dx[ix],Dx[iy],Dx[iz]);
                }
            }
        }          
    }
}
Exemplo n.º 6
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;
    }
}
Exemplo n.º 7
0
void Elastic::Boundary_Conditions::set_embedded_boundary
(const SAMRAI::hier::Patch& patch, const int &level_set_id,
 const int &dv_mixed_id)
{
  boost::shared_ptr<SAMRAI::pdat::SideData<double> > level_set_ptr=
    boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
    (patch.getPatchData(level_set_id));
  SAMRAI::pdat::SideData<double> &level_set(*level_set_ptr);

  boost::shared_ptr<SAMRAI::pdat::SideData<double> > dv_mixed_ptr;
  if(dv_mixed_id!=invalid_id)
    dv_mixed_ptr=boost::dynamic_pointer_cast
      <SAMRAI::pdat::SideData<double> >(patch.getPatchData(dv_mixed_id));

  const SAMRAI::tbox::Dimension dimension(patch.getDim());
  const Gamra::Dir dim(dimension.getValue());

  const SAMRAI::hier::Box gbox=level_set.getGhostBox();
  const SAMRAI::hier::Box box=level_set.getBox();

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

  /* Corners are not synced, so we set the level set to a generic
   * negative value and dv_mixed to zero.  Setting dv_mixed to zero
   * implies that we do not care about faults that intersect that
   * corner (nor should we). */
  for(Gamra::Dir ix=0; ix<dim; ++ix)
    {
      const Gamra::Dir iy(ix.next(dim));
      const Gamra::Dir iz(iy.next(dim));

      std::vector<std::vector<int> > corners(dim);
      corners[ix].push_back(box.lower(ix));
      corners[ix].push_back(box.upper(ix)+1);

      if(geom->getTouchesRegularBoundary(iy,0))
        corners[iy].push_back(gbox.lower(iy));
      if(geom->getTouchesRegularBoundary(iy,1))
        corners[iy].push_back(gbox.upper(iy));

      if(dim==3)
        {
          if(geom->getTouchesRegularBoundary(iz,0))
            corners[iz].push_back(gbox.lower(iz));
          if(geom->getTouchesRegularBoundary(iz,1))
            corners[iz].push_back(gbox.upper(iz));
        }

      SAMRAI::pdat::SideIndex x(SAMRAI::hier::Index(dimension),ix,
                                SAMRAI::pdat::SideIndex::Lower);
      for(std::vector<int>::iterator i=corners[ix].begin();
          i!=corners[ix].end(); ++i)
        {
          x[ix]=*i;
          if(dim==2)
            {
              for(std::vector<int>::iterator j=corners[iy].begin();
                  j!=corners[iy].end();++j)
                {
                  x[iy]=*j;
                  set_embedded_values(x,dim,level_set,dv_mixed_ptr);
                }
            }
          else
            {
              for(std::vector<int>::iterator j=corners[iy].begin();
                  j!=corners[iy].end();++j)
                for(int kk=gbox.lower(iz); kk<=gbox.upper(iz); ++kk)
                  {
                    x[iy]=*j;
                    x[iz]=kk;
                    set_embedded_values(x,dim,level_set,dv_mixed_ptr);
                  }
              for(std::vector<int>::iterator k=corners[iz].begin();
                  k!=corners[iz].end();++k)
                {
                  for(int jj=gbox.lower(iy); jj<=gbox.upper(iy); ++jj)
                    {
                      x[iy]=jj;
                      x[iz]=*k;
                      set_embedded_values(x,dim,level_set,dv_mixed_ptr);
                    }
                }
            }
        }
    }
}