Effect of filling factor on emissivities

[Alex Jones]

Hi all

I have been using pyCloudy's 3D methods to construct surface brightness profiles of a spherical planetary nebula model to be compared to long-slit spectroscopy observations. For example, I create a synthetic H-alpha image of the nebula using

(m3d.get_emis('H__1_656281A').sum(0) * m3d.cub_coord.cell_size) / (4 pi D^2)

I then extract a rectangular region with similar dimensions to the slit used in the spectroscopy, and sum the flux along one direction to create a profile. However, I am unsure what effect the filling factor has on the emissivities. To test this, I created 2 identical models, but one with a filling factor of unity and one that does not. For each model, I would expect the following two lines to return the same value:

print m3d.get_emis_vol('H__1_656281A', at_earth=True)

and

print sum((m3d.get_emis('H__1_656281A').sum(0) * m3d.cub_coord.cell_size) / (4 pi D^2))

This is true for the model with a filling factor of 1, but not true for the other model. I suppose my question is how can the total flux be unaffected by choice of filling factor, but the emissivity profile can be affected. I am interested in knowing as I want to make sure my synthetic surface brightness profiles have been flux-scaled correctly, and can be directly compared to my observed profiles.

I hope this makes sense, and any help would be greatly appreciated.

Thanks

Alex

[Christophe Morisset]

Hi Alex,

Sorry for the delay, things are quite messy in those times.

You are right that the filling factor is important when computing the line emission. You can directly have an idea of what the code is doing by putting 2 question marks after the method. You will then see that get_emis_vol is doing:

    def get_emis_vol(self, ref, at_earth=False):
        """
        Compute the intensity of a line.
        Parameters:
            - ref [int or str]: line reference
            - at_earth:    if True (not default): the result is divided by 4.pi.D2
        return:
            integral of the emissivity of the referred line on the volume of cube (erg/s)
        """
        if at_earth:
            coeff = 4. * np.pi * (self.m[0].distance * pc.CST.KPC) ** 2
        else:
            coeff = 1.
        return self.vol_integ(self.get_emis(ref)) / coeff

Is is basically calling vol_integ, which does the following:

    def vol_integ(self, a):
        """
        Volume integrator
        """
        return (a * self.ff * self.cub_coord.cell_size).sum()

As you can see, the integration over the volume takes into account the filling factor.

Hope it helps,

Christophe

[Alex Jones]

Hi Christophe

Thank you for your reply.

I am still not quite sure if I understand how exactly the filling factor is taken into account in the 3d models. For example, I have ran 2 models which are the same, except one has a filling factor of 1.0, and the other a factor of 0.5, which I call here mod_ff_10 and mod_ff_05 respectively. If I run the following code:

distance = 2.029

cube_size = 200

centre = 1

n_dim  = 1

mod_ff_10 = pc.load_models('./ff_10', read_grains=True, distance=2.029)[0]

m3d_ff_10 = pc.C3D(list_of_models=mod_ff_10, dims=cube_size, center=centre, n_dim=n_dim)

mod_ff_05 = pc.load_models('./ff_05', read_grains=True, distance=2.029)[0]

m3d_ff_05 = pc.C3D(list_of_models=mod_ff_05, dims=cube_size, center=centre, n_dim=n_dim)

line = 'H__1_656281A'

image_10 = np.sum(m3d_ff_10.get_emis(line).sum(0) * m3d_ff_10.cub_coord.cell_size)

image_05 = np.sum(m3d_ff_05.get_emis(line).sum(0) * m3d_ff_05.cub_coord.cell_size)

total_10 = m3d_ff_10.get_emis_vol(line)

total_05 = m3d_ff_05.get_emis_vol(line)

print image_10

print total_10

print image_05

print total_05

these 4 values are returned:

3.1034110050122826e+34
3.103411005012283e+34
6.211905912482647e+34
3.1059529562413223e+34

If the filling factor is taken into account when using "get_emis_vol", then I would expect "total_10" and "total_05" to be different, however they are almost the same. Furthermore, I would expect the values I have called "total" and "image" to be identical, however this only appears to be true for the case where a filling factor of unity is applied. 

I hope this makes sense, and sorry if I sound repetitive. I have also attached the input files I ran in case they may be helpful.

Thanks again

Alex

[Christophe Morisset]

Hi Alex,

You are considering a case where your model is radiation bounded. And even more than this, you model is entering the neutral region by quite a lot. You can plot H+/H vs. radius to check this. To do this easily, allow pyCloudy to write your input file, it will add the following:

save last element hydrogen ".ele_H"
save last element helium ".ele_He"
save last element carbon ".ele_C"
save last element nitrogen ".ele_N"
save last element oxygen ".ele_O"
save last element argon ".ele_Ar"
save last element neon ".ele_Ne"
save last element sulphur ".ele_S"
save last element chlorin ".ele_Cl"
save last element iron ".ele_Fe"
save last element silicon ".ele_Si"

And then you can more easily see what's happening. In the case of a radiation bounded model, all the ionizing photons are used to ionize the gaz, leading to recombination and some of these recombinations emit Halpha. Then one can say that Halpha is a ionizing photons counter. It does not depend on anything else (a little bit Te, dust content, metallicity, etc, but not that much). The nebula you are computing is absorbing all the photons, Halpha is the same in both models. The 05 model is twice the 10 in size, because of ff. But Ha is the same: 3.1e34. The problem with your image_05 is that you are taking the output of a model with ff=0.5, but computing the intensity omitting using this ff: the result is wrong, you obtain twice the correct value.

Hope it helps,

Christophe

[Alex Jones]

Hi Christophe

I think that makes sense. So basically if I want to generate a synthetic image when a filling factor is applied, I also need to multiply the image by the filling factor. For example:

image  = m3d_ff_05.get_emis(line).sum(0) * m3d_ff_05.cub_coord.cell_size * np.mean(mod_ff_05.ff_full)

I can then use this image to generate the surface brightness profiles that I need.

Thanks for all your help.

Alex

[Christophe Morisset]

Hi Alex,

I suggest you to apply the ff correction locally (one may imagine a model with ff changing within the nebula):

image  = (m3d_ff_05.get_emis(line) * m3d_ff_05.ff).sum(0) * m3d_ff_05.cub_coord.cell_size 

Saludos,

Christophe

[Alex Jones]

Hi Christophe

I shall do as you say. Thanks again for all your help.

Alex