Fix fluctuations in distant beams

I think I found a bug in the calculation of the distant fluctuations in both carrier and sideband beams. As I read it, at the moment, the GW signal and TTl couples to the local offsets. Shouldn't they couple to the propagated distant ones as indicated also in the "Unified model document" (see

$\nu_{21}^o$

below)?

In my opinion

self.distant_carrier_fluctuations = \
    propagated_carrier_fluctuations \
    - (self.central_freq + self.local_carrier_offsets) * self.gws \
    - (self.central_freq + self.local_carrier_offsets) * self.local_ttls / c

should really read

self.distant_carrier_fluctuations = \
    propagated_carrier_fluctuations \
    - (self.central_freq + self.distant_carrier_offsets) * self.gws \
    - (self.central_freq + self.distant_carrier_offsets) * self.local_ttls / c

or am I missing something?

@j2b.bayle and @ohartwig could you double check this before I create a merge request?

Hi @mastaa! Yes, that indeed looks wrong.

Just out of curiosity, how did you discover it? Did you just happen to notice it, or did it actually cause a problem?

It should be a pretty small correction, which we usually assumed doesn't make a big difference for the GW signal (but sometimes those assumptions turn out to be wrong).

Hi @ohartwig,

it was completely be chance and I also understand that this MHz correction to the THz laser frequency shouldn't make any noticeable difference.

Agreed, this looks like a small bug!

assigned to @mastaa

changed milestone to %v1.5

added bug label

changed milestone to %v1.6

assigned to @j2b.bayle and unassigned @mastaa

created branch 133-fix-fluctuations-in-distant-beams to address this issue

mentioned in merge request !164 (merged)

It's probably past time that we fixed this.

In the simulation model (equation 30b shown by Martin), the link response couples with the central frequency and the delayed distant carrier offsets, i.e., something like

self.local_carrier_offsets.distant() \
.transformed(lambda mosa, x: self.interpolate(x, -self.pprs[mosa]), concurrent=self.concurrent)

As far as I understand, this is different from what you propose @mastaa, because self.distant_carrier_offsets corresponds to equation 30a contains in addition to the delayed distant carrier offsets the Doppler shifts.

Therefore, I would suggest something like

        ## Propagation to distant MOSA

        logger.info("Propagating local beams to distant MOSAs")

        logger.debug("Propagating carrier offsets to distant MOSAs")
        delayed_distant_carrier_offsets = self.local_carrier_offsets.distant() \
            .transformed(lambda mosa, x: self.interpolate(x, -self.pprs[mosa]), concurrent=self.concurrent)
        self.distant_carrier_offsets = \
            -self.d_pprs * self.central_freq \
            + (1 - self.d_pprs) * delayed_distant_carrier_offsets

        logger.debug("Propagating carrier fluctuations to distant MOSAs")
        carrier_fluctuations = \
            self.local_carrier_fluctuations \
            - (self.central_freq + self.local_carrier_offsets) * self.distant_ttls / c
        propagated_carrier_fluctuations = \
            (1 - self.d_pprs) * carrier_fluctuations.distant() \
            .transformed(lambda mosa, x: self.interpolate(x, -self.pprs[mosa]), concurrent=self.concurrent)
        self.distant_carrier_fluctuations = \
            propagated_carrier_fluctuations \
            - (self.central_freq + delayed_distant_carrier_offsets) * self.gws \
            - (self.central_freq + self.local_carrier_offsets) * self.local_ttls / c

        logger.debug("Propagating upper sideband offsets to distant MOSAs")
        delayed_distant_usb_offsets = self.local_usb_offsets.distant() \
            .transformed(lambda mosa, x: self.interpolate(x, -self.pprs[mosa]), concurrent=self.concurrent)
        self.distant_usb_offsets = \
            -self.d_pprs * self.central_freq \
            + (1 - self.d_pprs) * delayed_distant_usb_offsets

        logger.debug("Propagating upper sideband fluctuations to distant MOSAs")
        usb_fluctuations = \
            self.local_usb_fluctuations \
            - (self.central_freq + self.local_usb_offsets) * self.distant_ttls / c
        propagated_usb_fluctuations = \
            (1 - self.d_pprs) * usb_fluctuations.distant() \
            .transformed(lambda mosa, x: self.interpolate(x, -self.pprs[mosa]), concurrent=self.concurrent)
        self.distant_usb_fluctuations = \
            propagated_usb_fluctuations \
            - (self.central_freq + self.delayed_distant_usb_offsets) * self.gws \
            - (self.central_freq + self.local_usb_offsets) * self.local_ttls / c

What do you think @mastaa and @ohartwig ?

Hi @j2b.bayle,

yes I think you are right! To be completely correct we have to delay the distant offsets and then couple GWs and TTL to them. I also spotted that we don't do that for the carrier either. There we also couple GWs and TTL to self.central_freq + self.local_carrier_offsets which is wrong, right?

For reference:

self.distant_carrier_fluctuations = \
    propagated_carrier_fluctuations \
    - (self.central_freq + self.local_carrier_offsets) * self.gws \
    - (self.central_freq + self.local_carrier_offsets) * self.local_ttls / c

Mmm… I'm not sure I understand your comment. In the code I proposed, the GWs are coupled to self.central_freq + delayed_distant_carrier_offsets which I think is exactly what we want?

Yes, I agree very much!

And I understand your confusion, I misread. I thought you are only proposing the change for the sidebands but of course you have already included the carriers as well!

Great!

The one thing I have not included is this change for TTL. I am not sure what should be the coupling. Intuitively, I would expect that Doppler shifts should be included, so that the coupling factor would be self.central_freq + self.distant_carrier_offsets.

About TTL, good question... We should probably ask one of the experts.

Indeed!

@Sarah @guwann @Marie

Maybe our calls will be answered .

I'm jumping in the middle of the conversation here but I believe we have to distinguish between the local TTL effect and the remote. In each ISI, we have a TTL effect from the local jitter compared to an incoming, delayed and doppler-shifted beam and then we have TTL on the outgoing beam because of our local jitter.

Does that help? Do you want to add something @guwann and @Marie?

Could we do this via zoom? That would be more easy

Sure. Are you available now?

Thanks a lot @guwann for your time and help. I think we all agree that the current coupling is also wrong and should be changed to:

self.distant_carrier_fluctuations = \
    propagated_carrier_fluctuations \
    - (self.central_freq + delayed_distant_carrier_offsets) * self.gws \
    - (self.central_freq + delayed_distant_carrier_offsets) * self.local_ttls / c

so that the RX TTL contributions couple with the already Doppler-shifted beam frequency (here represented as delayed_distant_carrier_offsets).

mentioned in commit 4775f4c0

closed with merge request !164 (merged)