data/PDE2D/Solver/variable/wos_variable_rejection.py

import numpy as np
from ..data_holder import DataHolder
from ...Coefficient import *
from ...Sampling import *
from ...BoundaryShape.interaction import BoundaryInfo
from PDE2D.BoundaryShape import *
from .wos_variable import *

class WosVariableRejection(WosVariable):
    def __init__(self, input : DataHolder, seed : int = 37, weight_window = [0.5, 2],  max_z : float = 4, 
                 green_sampling : GreenSampling = 0, newton_steps : int = 5, use_accelaration : bool = True,
                 opt_params : list[str] = []):
        super().__init__(input, seed,  weight_window, max_z, 
                         green_sampling, newton_steps, use_accelaration, opt_params)
        
    @dr.syntax(print_code = False)
    def take_step(self, L : ArrayXf, p : Particle, mode : dr.ADMode, split : Split, dL : ArrayXf, active : Bool, active_conf : ArrayXb = ArrayXb(True),
                  conf_numbers : list[UInt32] = None, max_length : UInt32 = None, tput_kill : Float = Float(0.8), 
                  fd_forward : bool = False, illumination_mask : Bool = Bool(True)):
        if conf_numbers is not None:
            num_conf = len(conf_numbers)
        else:
            num_conf = 1
        
        primal = (mode == dr.ADMode.Primal)
        bi = self.input.shape.boundary_interaction(p.points, star_generation = False, conf_numbers = conf_numbers)
        
        if bi.is_far:
            p.thrown = Bool(True)
            active &= Bool(False)
        
        # Decrease radius if it is big. 
        σ_bar = self.input.σ_bar
        z = Float(0)
        if self.use_accel:
            bi.r, σ_bar, z = self.input.get_Rσz(p.points, bi.r)
        else:
            z = bi.r * dr.sqrt(σ_bar)
            if z > self.max_z:
                bi.r *= self.max_z / z
                z = self.max_z
        
        self.green.initialize(z)
        dirichlet_ending = (active & bi.is_e & bi.is_d) 
        
        # Add the dirichlet boundary contribution in epsilon-shell!
        added_near = dr.select(dirichlet_ending & active_conf, p.w * bi.dval, 0)

        L += added_near if primal else -added_near

        with dr.resume_grad(when=not primal):
            α = self.input.α.get_value(p.points)
            
        # Remove the channels in which the walk is finished. 
        active &= ~dirichlet_ending

        f_cont = Float(0)        
        # Add the source contribution.
        if dr.hint(not self.input.f.is_zero, mode = 'scalar'):
            sample_source = Point2f(p.sampler.next_float32(), p.sampler.next_float32())
            #if illumination_mask:
            #r_vol, normG = self.green.sample(sample_source[0], bi.r, σ_bar)
            r_vol, normG = self.sampleGreenRejection(p, bi.r, σ_bar)
            dir_vol, _ = sample_uniform_direction(sample_source[1])
            points_vol = p.points + r_vol * dir_vol 
            with dr.resume_grad(when=not primal):
                α_vol = self.input.α.get_value(points_vol)
                f_vol = self.input.f.get_value(points_vol) 
                f_cont = p.w * f_vol * normG / dr.sqrt(α * α_vol)
                if dr.isnan(f_cont) | ~illumination_mask:
                    f_cont = Float(0)

        f_cont = dr.select(active_conf, f_cont, 0)
        L += f_cont if primal else -f_cont

        # Now select between boundary or volume sampling (2nd paper, eqn 28)
        normG = self.green.eval_norm(bi.r, σ_bar)
        prob_vol =  σ_bar * normG
        sample_rec = Point2f(p.sampler.next_float32(), p.sampler.next_float32())
        sample_vol = active & (sample_rec[0] < prob_vol)
        sample_rec[0] = dr.select(sample_vol, sample_rec[0] / prob_vol, (sample_rec[0] - prob_vol) / (1-prob_vol))

        r_next = Float(bi.r)
        if sample_vol:
            #r_next = self.green.sample(sample_rec[0], bi.r, σ_bar)[0]
            r_next = self.sampleGreenRejection(p, bi.r, σ_bar)[0]
            
        dir_next, _ = sample_uniform_direction(sample_rec[1])
        points_next = p.points + r_next * dir_next
        

        with dr.resume_grad(when=not primal):
            α_next = self.input.α.get_value(points_next)
            grad_α_next, laplacian_α_next = self.input.α.get_grad_laplacian(points_next)
            σ_next = self.input.σ.get_value(points_next)
            σ_new = self.σ_(σ_next, α_next, grad_α_next, laplacian_α_next)
            w_ = dr.select(active, dr.sqrt(α_next / α), 1.0)
            w_s = dr.select(sample_vol, (1.0 - σ_new / σ_bar), 1.0)
            w_update = w_ * w_s
            # Boundary and Volume Contribution
            prb_cont = dr.select(dr.isfinite(w_update), L * w_update / dr.detach(w_update), 0.0)

            if dr.hint(mode == dr.ADMode.Backward, mode = 'scalar'):
                dr.backward(dr.sum((prb_cont + f_cont) * dL)) 
            elif dr.hint(mode == dr.ADMode.Forward, mode = 'scalar'):
                dL += dr.forward_to(dr.sum(prb_cont + f_cont))
            
        p.w *= w_update
        # If we are not doing fd computation, then just use the original coefficient.
        if dr.hint((not fd_forward), mode = 'scalar'):
            if dr.hint(split == Split.Agressive, mode = 'scalar'):
                p.w_split *= w_update
            elif dr.hint(split == Split.Normal, mode = 'scalar'):
                p.w_split *= w_s
        else:
            α = self.input.α_split.get_value(p.points) # We did not get this before if f is zero!
            α_next = self.input.α_split.get_value(points_next)
            grad_α_next, laplacian_α_next = self.input.α_split.get_grad_laplacian(points_next)
            σ_next = self.input.σ_split.get_value(points_next)
            σ_new = self.σ_(σ_next, α_next, grad_α_next, laplacian_α_next)
            w_ = dr.select(active, dr.sqrt(α_next / α), 1.0)
            w_s = dr.select(sample_vol, (1.0 - σ_new / σ_bar), 1.0)
            if dr.hint(split == Split.Agressive, mode = 'scalar'):
                p.w_split *= (w_ * w_s)
            elif dr.hint(split == Split.Normal, mode = 'scalar'):
                p.w_split *= w_s

        if dr.hint(max_length is not None, mode = 'scalar'):
            if p.path_length > max_length:
                p.w *= tput_kill
                p.w_split *= tput_kill

        active &= dr.isfinite(w_update)
        p.points = points_next
        p.path_length += 1
        return p
    
    @dr.syntax
    def sampleGreenRejection(self, p : Particle, R : Float, σ : Float):
        # We apply rejection sampling based on WosVariable paper.
        if R <= σ:
            upper_bound = dr.maximum(2.2 * dr.maximum(dr.rcp(R), dr.rcp(σ)), 0.6 * dr.maximum(dr.sqrt(R), dr.sqrt(σ)))
        else:
            upper_bound = dr.maximum(2.2 * dr.minimum(dr.rcp(R), dr.rcp(σ)), 0.6 * dr.minimum(dr.sqrt(R), dr.sqrt(σ)))

        sample1 = p.sampler.next_float32() * R
        sample2 = p.sampler.next_float32() 
        pdf = self.green.eval_pdf_only(sample1, R, σ)
        while(sample2 * upper_bound > pdf):
            sample1 = p.sampler.next_float32() * R
            sample2 = p.sampler.next_float32()
            pdf = self.green.eval_pdf_only(sample1, R, σ)
        return sample1, self.green.eval_norm(R, σ)