def METHOD_NAME(self, ray_bundle: RayBundle):
    # bootstrap with original Neus
    if self.sampler._update_counter.item() <= 0:
        return super().METHOD_NAME(ray_bundle)
    ray_samples, ray_indices = self.sampler(ray_bundle, sdf_fn=self.field.get_sdf, alpha_fn=self.field.get_alpha)
    if ray_samples.shape[0] > 0:
        field_outputs = self.field(ray_samples, return_alphas=True)
        n_rays = ray_bundle.shape[0]
        weights = nerfacc.render_weight_from_alpha(
            field_outputs[FieldHeadNames.ALPHA],
            ray_indices=ray_indices,
            n_rays=n_rays,
        )
        rgb = nerfacc.accumulate_along_rays(
            weights, ray_indices, values=field_outputs[FieldHeadNames.RGB], n_rays=n_rays
        )
        normal = nerfacc.accumulate_along_rays(
            weights, ray_indices, values=field_outputs[FieldHeadNames.NORMAL], n_rays=n_rays
        )
        accumulation = nerfacc.accumulate_along_rays(weights, ray_indices, values=None, n_rays=n_rays)
        depth = nerfacc.accumulate_along_rays(
            weights,
            ray_indices,
            values=(ray_samples.frustums.starts + ray_samples.frustums.ends) / 2,
            n_rays=n_rays,
        )
        # the rendered depth is point-to-point distance and we should convert to depth
        depth = depth / ray_bundle.directions_norm
        outputs = {
            "rgb": rgb,
            "accumulation": accumulation,
            "depth": depth,
            "normal": normal,
        }
        if self.training:
            grad_points = field_outputs[FieldHeadNames.GRADIENT]
            outputs.update({"eik_grad": grad_points})
    else:
        zeros = torch.zeros((ray_bundle.shape[0], 3), dtype=torch.float32, device=self.device)
        outputs = {"rgb": zeros, "accumulation": zeros[:, :1], "depth": zeros[:, :1], "normal": zeros}
        if self.training:
            outputs.update({"eik_grad": zeros})
    # this is used only in viewer
    outputs["normal_vis"] = (outputs["normal"] + 1.0) / 2.0
    return outputs