ID 
Date 
Author 
Type 
Category 
Subject 
115

Thu Nov 2 17:23:56 2017 
Aaron  Mechanics  PonderSqueeze  Modelling suspension noise  aLIGO Suspensions Toy Model
On Wednesday I started making my own model of the aLIGO suspensions, with the top of the silica fibers attached to ears that are fixed rather attached to an additional suspension stage (so this will be a one stage suspension).
I grabbed the aLIGO ear design from the DCC: LIGOD080751v4
I am almost done with the model, should have it working tomorrow and will add it to the experimental gravity github in an appropriate place. 
116

Fri Nov 3 15:03:10 2017 
Aaron  Mechanics  PonderSqueeze  Modelling suspension noise  Model Geometry
Test Mass
I found the dimension of the test mass flat in the drawings of the mock test mass design here: LIGOD080687.
Fibers
I modelled the fibers with the profile described in LIGOD080751, fig 3.7.
Ears
I grabbed the dvalues from LIGOT1000545, but since the dvalue is defined as the distance from the center of mass (of the penultimate mass (PUM) or the E/ITM) to the bend point (BP) of the fiber (I believe the point on the fiber with maximal flexure in the fundamental mode), I did not go through the effort of figuring out where the bend point is but rather grabbed the hornCM distance from LIGOT1100407
I wanted to get the real aLIGO parameters for the first version of this model, and have parametrized the model in such a way that I can define all of the parameters that need to change (surface area of the earTM bond, length of the fibers, thickness and profile of fibers, dvalue, etc) and scale them with mass in some way for future iterations on this design.
I need to pare down the number of parameters, because I started by fully defining the ears and now am importing a 3D model of the ears and planning to scale these with mass.
Materials
For the material of the entire test mass and suspension, I used the fused silica that is specified as [solid,NIST SRM 739  Type I]. I wasn't sure the difference between the types of silica, but this one said SRM so I thought it might have been defined on my distribution of COMSOL by a LIGO person. A quick google search showed me that person may have been rana?? https://labcit.ligo.caltech.edu/~rana/research/etm.html
Physics
I'm using a solid mechanics model.
Fixed Boundary Constraint
I fixed the position of the bonding surfaces for the PUM ears, so it is as if they are contacted to a completely fixed PUM (the PUM is not included in the model, but the upper ears are included, so the constraint is on the ears not the fiber. See drawing).
Gravity
I added gravity to all parts of the model. Apparently, it is not trivial to use gravity in a frequency domain study in COMSOL, as described in this presentation here. Fortunately, the presentation in the link is interested in the transfer function for a mass on a string also, so I follow the simulation steps they describe below.
Boundary Load
I add a boundary load that will vary sinusoidally for the frequency domain study.
Mesh
I have not yet messed with the meshing for these models. Obviously the points with more flexture and smaller parts (like at the horns of the ears, the tapering parts of the fibers, etc) will require a finer mesh.
Study
I need to incorporate the advice on how to build this study described in the link above. The following might also be useful, though I haven't looked through them yet:
https://www.comsol.com/model/dynamicsofdoublependulum14021
https://www.comsol.se/forum/thread/4843/pendulumresponse?last=20100427T01:48:26Z 
117

Wed Nov 15 14:05:12 2017 
Aaron  Mechanics  PonderSqueeze  Modelling suspension noise  Model Geometry
I pared down the number of parameters in the model to only the necessary ones. These are the ones that remain:
TM_radius: Radius of the test mass
TM_width: Width of the test mass
TM_flats: length of TM flats
ear_length: length of the ear
horn_spacing: length of the ear
horn_gap: gap between the top of the horn and the TM on the near side
d_val: distance from the CM to the bend point
horn_BP: distance from the horn to the bend point
ear_height_tot_nominal: nominal total height of the ear and horn for the unscaled (aLIGO) design (this name made more sense in a previous version of the model)
fiber_stock_length: length of the fiber's stock
fiber_neck_length: length of the fiber's neck
fiber_thick_length: length of the thick section of the fiber
fiber_main_length: length of the main section of fiber (the thinnest part)
fiber_taper_length: length of the tapering section of fiber
fiber_stock_radius: radius of the fiber stock
fiber_thick_radius: radius of the thick section of fiber
fiber_main_radius: radius of the main section of fiber
F_load: force of the boundary load used for the excitation in the frequency domain study
ear_scale_height: scale the height of the ear
ear_scale_length: scale the length of the ear
ear_scale_width: scale the width of the ear
Materials
For the material of the entire test mass and suspension, I used the fused silica that is specified as [solid,NIST SRM 739  Type I]. I wasn't sure the difference between the types of silica, but this one said SRM so I thought it might have been defined on my distribution of COMSOL by a LIGO person. A quick google search showed me that person may have been rana?? https://labcit.ligo.caltech.edu/~rana/research/etm.html
Physics
Rana suggests that for the purpose of this study, it is not necessary to actually have COMSOL handle gravity as a restoring force... I'm not sure if I understand why this is yet? It seems that if we are interested in the relative strain energy in different parts of the wire compared to other parts of the system, it is important that the wire be under tension. If we have no gravity, the wire is effectively not under tension.
Mesh
I have not yet messed with the meshing for these models. Obviously the points with more flexture and smaller parts (like at the horns of the ears, the tapering parts of the fibers, etc) will require a finer mesh.
Study
I need to incorporate the advice on how to build this study described in the link above. The following might also be useful, though I haven't looked through them yet:
https://www.comsol.com/model/dynamicsofdoublependulum14021
https://www.comsol.se/forum/thread/4843/pendulumresponse?last=20100427T01:48:26Z 
32

Tue Jun 25 15:16:59 2013 
Arnaldo Rodriguez  Optics  General  Setting Up Looped Simulation for PID Controller  After setting up a COMSOL model that includes the heat flux from the laser and the ring heater, I've made the model solve over time manually by performing the solution process over a loop in MATLAB.
This allows for the future insertion of the PID controller object in the solving process, and the dynamic manipulation of the applied heat loads.
The following is an automatically generated plot of defocus effects as a function of time at 1 beam radius (54 mm), included in the program, with only the ring heater turned on in a tophat emission configuration and the total power being 5 watts.
The linear projection values needed to calculate the defocus effect are extracted directly from COMSOL, with no output files required through the use of the mphinterp command.
The behavior appears to be physical and is of the correct order of magnitude.
I've also attached the code that produced it for verification. (It requires COMSOL+Matlab to run.)

Attachment 2: ITMPlusRing.m

% function out = model
%
% ITMPlusRing.m
%
% Model exported on Jun 24 2013, 16:24 by COMSOL 4.3.0.151.
deltat = 600;
totalt = 3600*24;
t = [0:deltat:totalt];
omega = 54/1000;
... 275 more lines ...

34

Wed Jun 26 13:52:06 2013 
Arnaldo Rodriguez  Optics  General  Verifying Relative Error in Defocus for Regular and ManualLoop Simulations  To verify the validity of the solutions produced by the manual simulation, I've calculated the relative error between the results from the manual code and the results produced by COMSOL normally.
The plot for the relative error in the defocus at r = 0 and r = 54 mm is shown below, in the case where only the ring heater is turned on at a total power of 5 W.
The following indicates that the maximum error is less than 0.01% (in percent error format).

35

Wed Jun 26 15:23:55 2013 
Arnaldo Rodriguez  Optics  General  Solving Time per Loop in Manual Dynamic Simulation  I've attempted to determine the solving time per loop as a function of the simulation time, in an attempt to identify any trends in the solving time for a constantly dynamic load.
The following is a plot of the solving time per loop as a function of the simulation time for a load which is constantly dynamic (sinusoidal in time, in this particular run).
The mesh size is normal (default in COMSOL) with heat fluxes from both the beam and the ring heater (as in the real case).
It is difficult to identify any particular behavior or trend due to the large amount of "noise" other than a trivial general increase after ~4 s. Mesh quality does not appear to influence solving time per loop significantly.
Work must be done to reduce the total solving time for the simulation, which in this case amounted to 18 and a half minutes (1.1109e+03 seconds).

38

Thu Jun 27 15:06:13 2013 
Arnaldo Rodriguez  Optics  General  PID Function in Manual Simulation  I have inserted a rudimentary PID function into the manual simulation code as a way to test whether or not the PID function is changing the defocus values in the desired manner.
I am currently determining the ratio of ring heater power to the steadystate defocus as a way of measuring the scale of the response.
This ought to give a good way of measuring the scale needed to convert the calculated actuator response into an actual load.
I've attached the rudimentary code below. (The actuator isn't feeding into the heater at the moment, but inserting the "actuation" variable into the load expression is all that is required.)

Attachment 1: ITMPlusRingPlusPID.m

% function out = model
%
% ITMPlusRing.m
%
% Model exported on Jun 24 2013, 16:24 by COMSOL 4.3.0.151.
u = zeros(1,2);
e = zeros(1,3);
mtime = 0;
deltat = 600;
... 292 more lines ...

Attachment 2: PID.m

function [u, e] = PID(s, u, e, Ki, Kp, Kd, deltat, s_target)
u(2) = u(1);
e(3) = e(2);
e(2) = e(1);
e(1) = s  s_target;
u(1) = u(2) + Ki*e(1)*deltat + Kp*(e(1)  e(2)) + Kd*(e(1)  2*e(2) + e(3))/deltat;
end

39

Thu Jun 27 17:12:33 2013 
Arnaldo Rodriguez  Optics  General  Defocusing in PControlled Manual Simulation  To test the effectiveness of the PID loop, I've only given a nonzero value to the K_p constant and varied it over a series of runs to verify the response by the controller.
The following is a plot of the baseline compared to the Pactive simulations for different proportionality gain constants. I've yet to determine whether all the trends in behavior are physical.
Each different case has an evident droop (steadystate error), and seem to be destabilizing as K_p increases. However, most cases reach steadystate quicker than the baseline.
It should be noted that the ring heater is not correcting any effects from the beam, as it is turned off. The ring heater is correcting itself; or rather, its own initial heat pulse of 5 W * delta_t (600s) = 3000 J before the controller becomes active. 
42

Mon Jul 1 13:01:58 2013 
Arnaldo Rodriguez  Optics  General  Brief Parameter Study on Pactive Control Loop  The following is a plot of the defocus as a function of time with only the proportional gain being nonzero. Only three cases were run before the program crashed.
The dotted line indicates the setpoint.
One can clearly see the loop becomes unstable and oscillates out of control at a proportional gain of 240, and can see the characteristic steadystate offset of the Pcontroller from the set point develop in the other cases. 
43

Mon Jul 1 17:31:40 2013 
Arnaldo Rodriguez  Optics  General  Parameter Study on Sampling Time for Pactive Loop  The following is a plot of the defocus as a function of time for a fixed proportionality gain of 150, and different listed sampling times.
The discrepancy between the behaviors is enough to warrant a proper mathematical explanation; the max. overshoot, for example, is inversely proportional to the sampling rate.

131

Thu Feb 14 12:38:51 2019 
Ching Pin  Mechanics   comsol modelling  So I did a simple comsol model of laser heating of a silicon disk, with only radiation, to see the temperature variation at steady state, which could be the limiting factor for high Q at 123 K, due to the thermalelastic effect.
The model just uses a simple 2 inch disc, at 0.028 cm thick, with the flats not incorporated in yet.
I had to search for silicon thermal conductivity and heat capacity at low temperatures, settling with k= 800 W/(m K) and C_p= 300 j/(kg K) from refering to papers. Will check LIGO documents for more accurate versions.
I put an arbitary boundary condition of constant temperature of 123 K on a spot .2 mm in radius, to simulate a beam.
Other arbitary values include 77 K for ambient and a surface emissivity of 0.5.
The laser is off center, because that it where the laser will enter the current setup.
We can see that the power required is .02 W, which seems reasonable.
The model is consistent with the analytic model I made with the laser beam at the centre of the disc. See last two figures.
I'm still trying to get the time dependence to work, as it is just giving me nonsense right now.
Some thoughts: beam radius affects the temperature variation quite significantly, with a fat beam (1 mm radius) having half the temperature variation as a beam of .2 mm radius
I think the halo is just a trick of the eye, but I could be wrong.
Things to do:
Find the time scale of the system, as we want to modulate the laser to adjust the temperature, which will then be run though the mode ringer to measure Q to find the zero crossing
Change the heat source to be an actual laser
Add in the solid mechanics part
Add in the sapphire lens underneath 
Attachment 1: Screenshot_from_20190214_124711.png


Attachment 2: Screenshot_from_20190214_150740.png


Attachment 3: Screenshot_from_20190214_154141.png


Attachment 4: graph.pdf


132

Fri Feb 15 21:05:31 2019 
Ching Pin  Mechanics   comsol modelling 
So I got the time dependence to work, but I'm not sure what went wrong in the first time anyways. I'll trying to get a sense of how long it takes for the temerature to semiequlibrate, and coming to grips with comsol as a whole. There seems to be some inaccuracies when the timing increases, so I'm having to figure out how to increase accuracy without drastically increasing compute time. On the bright side, I switched the model to heating via deposited beam, for a more accurate model.
Attached is comsol's handling of a deposited beam modulated sinusoidally with a frequency of 0.1 Hz and screwing up badly. Y axis is the average surface tempurature across the whole disc.

Attachment 1: Screenshot_from_20190215_214001.png


133

Tue Feb 19 19:52:53 2019 
Ching Pin  Mechanics   comsol modelling  The time step response to heating via laser (22.5 mW) is given in the attached picture, for 2 starting temperatures, 122.5 K and 122.8 K. We see that it takes fairly long to equlibrate, with a time constant of about 500 s, and is consistent across both temps. The y axis is average temperature across the surface of the disc, and the x axis is time. I believe that the heat distribution profile would be very similar with time, simply because of how much faster conduction is compared to radiation 
Attachment 1: Screenshot_from_20190219_195210.png


134

Fri Mar 1 19:33:40 2019 
Ching Pin  Mechanics   comsol modelling  I've changed the heating to be from two heat sources, to better model the situation with a heater and a laser. The heater deposits 22 mW, with the laser deposting .5 mW. The overall temperature distribution is smaller then before, as expected, but doesn't really change much. The heater is simulated with a deposited beam with a gassian beam profile with a standard deviation (s.d.) of 8 mm. The laser to the size has a .3 mm s.d. for contrast. I learned that while the deposited beam power doesn't care for emisitivity, it cares about the area the beam is incident with, so for example, if you increase the s.d. too much, you get less power deposited then what you enter.
I've also got modes to appear using solid mechanics, and I'm trying to see if there is a good way to get the frequency dependence with temperature nicely simulated. Changing the parameters of the simulation does give me my different frequencies, but I trying to find a way to do that over the time evolution of the model. I also got to check if the frequency shift is in line with what we are measuring. 
Attachment 1: Screenshot_from_20190301_193532.png


Attachment 2: Screenshot_from_20190301_193602.png


Attachment 3: Screenshot_from_20190301_194625.png


135

Mon Mar 4 17:22:07 2019 
Ching Pin  Mechanics   comsol modelling  I've updated the material properties to vary with temperature, mainly in the range of 90140 K. Using the parametric sweep function to vary the input power of the heater, we get the eigenfreqencies' dependence on temperature to show up. The fractional dependence of 1.3e5 /K around 123 K matches with what Aaron calculated in this elog entry, which is always a good sign that nothing is going horribly wrong. I've also added the flats to the silicon disc, for better accuracy. See the screenshots below showing the frequency shift with temperature. 
Attachment 1: Screenshot_from_20190304_191328.png


Attachment 2: Screenshot_from_20190304_191441.png


Attachment 3: Screenshot_from_20190304_191537.png


Attachment 4: Screenshot_from_20190304_191556.png


136

Wed Mar 6 09:51:18 2019 
Ching Pin  Mechanics   comsol modelling  So I tried adding the sapphire lens to the comsol model, and I am having teething issues. I can't seem to get the solver to converge, but I'm working on it. 
Attachment 1: Screenshot_from_20190306_093124.png


137

Thu Mar 7 10:10:37 2019 
Ching Pin  Mechanics   comsol modelling  There are no issues with the thermal side of the modeling, the issue seems to be with the structural mechanics side. I'm not sure what I'm doing wrong though, but it just isn't converging. In any case, seeing that this is my last day here, I'll just point out that the version without the lens is saved in cvs/cds/caltech/users/cp/current working model.mph, while the model with the lens is saved in the same folder under the file name testing with lens.mph, using optimus. There is also a small file edition of current working model, with a file name that is self evident. I'll leave it to aaron to upload that to git.
In any case, let me just put down some documentation and thoughts on this model: The physical parameters on the model are generally what we do know of silicon at these temperatures, with the exception of emissitivity, which was randomly given a parameter of .5. The model is currently absorbing 22 mW from the heater and .5 mW from the laser, which implies that the heater should be able to have 45 mW incident on the disc, which would in turn suggest that you would want it to at least dissapate 100 mW to account for the lack of direction from radiation. Because comsol's deposit beam power function does not care for emissitivity, it must be modified in tandem with it. 
Attachment 1: Screenshot_from_20190307_101047.png


77

Wed Nov 13 23:55:44 2013 
Chris Couste  Optics  Analysis  Optical Mount Vibrational Analysis  Project: Vibrational Analysis of Optical Mounts
Goal: Use COMSOL to run finite element analysis on simplified models of different types of optical mounts available to us, in order to find which shape/style/material reacts the least to external sound pollution. Once the few best candidates have been identified, develop test to experimentally determine optimal mount configuration and material.
Part 1: FEM
Process: Simultaneously build models in SolidWorks and design analysis in COMSOL
Solidworks: base/shaft models based on measurements of actual optical mounts, optic holder models matching mass and moment of inertia from downloaded models from their manufacturers. ~Progress: base/shaft done, optic holders almost done.
COMSOL: Design analysis that first does a general eigenfrequency analysis to find general vicinity of modes, then does a full modal frequency analysis. ~Progress: finished, ready for models to be imported. 
78

Mon Nov 18 15:56:59 2013 
Chris Couste  Optics  Analysis  Representative Models  The simpler models of the optical mounts are finished, they will be run through the comsol analysis software soon.
see pictures below:

Attachment 1: Custom_Closed.JPG


Attachment 2: custom_open.JPG


Attachment 3: Stock_Closed.JPG


Attachment 4: Stock_Open.JPG


79

Fri Nov 22 21:04:53 2013 
Chris Couste  Optics  Analysis  analysis  The analysis is making nice eigenmode and stress mode models, but the displacement experiment needs work. Should be fixed by monday. 
80

Fri Jan 24 17:26:38 2014 
Chris Cousté  Optics  Analysis  Mount Analysis Functional!  The comsol eigenmode analysis is complete, and the only thing left to do on this part of the project is to run the analysis on a range of different configurations of optical mounts as well as a range of materials. This compilation will be posted on this elog in the next few weeks, due to the fairly long runtime of the analysis software. 
81

Sun Feb 16 21:10:56 2014 
Chris Cousté  Optics  Analysis  Optical Mount data compilation 1: Aluminum  The time is finally here! this is the highest displacement of each mount in its lowest few eigenfrequencies, using 6061 Aluminum as a material. pictures will be added in a future log, because I'm going to make them into one file. Other materials will also be tested to see if there is variance in these findings, but only relevant data will be posted.
tl;dr findings: thickopen is the best combination because it has less displacement in eigenmodes and its eigenmodes are all very high/spread apart in frequency.
long:
(key) Eigenfrequency (Hz), highest displacement (mm), direction
Thin base, open mount:
315, 8.07, leaning back (laser will angle up)
316, 7.94, leaning to the side (laser won't change direction if the optic is flat, i.e. point of contact moves along surface of optic)
924, 10.50, twist to the side (laser will angle to the side)
1949, 8.89, twist about optic, slight lean forward (point of contact will move slightly, laser may angle down)
2144, 10.47, another leaning forward mode
thin base, open mount:
322, 13.29, leaning forward and translating to the side
328, 13.36, same as above
994, 17.66, twisting to the side (laser will angle to the side)
1943, 13.86, intense leaning forward
2100, 14.27, twist about optic
thick base, closed mount:
1329, 13.23, leaning back
1347, 13.32, leaning back and to the side
3577, 15.46, twisting to the side
thick base, open mount:
1326, 9.69, leaning to the side
1335, 9.77, leaning back
3504, 13.88, twisting to the side

All of these frequencies were checked for all four models, and the max displacements in those cases ranged from 100 picometers to 10 femtometers, so it's pretty reasonable to base decisions off of the displacements at the eigenmodes.
Based on this, it seems that for both thick and thin, open is the best, considering it displaces significantly less than closed (which is reasonable because there is less mass at the top to be thrown around). The choice between thick and thin depends on what frequencies we believe the mounts will be subjected to. If we are probably not going to have much sound at frequencies above 1000Hz, then thick is the better option (which is nice because it is the stock stalk instead of the custom made one). However, if there will be plenty of high noise, the thick is still probably the better option because it has fewer eigenmodes in the same range of frequencies.
here's a sample of two pictures of the relevant eigenmodes of the winner.

Attachment 1: aluminum2.png


Attachment 2: aluminum3.png


8

Wed Jun 5 13:49:13 2013 
Deep Chatterjee  Optics  General  Difference in the Levin and Liu & Thorne results for thermal noise  The analytical expressions for thermal noise, as calculated by Liu & Thorne and Levin, was plotted as a function of frequency in a log  log plot using Matlab.
The value of the parameters were used from Levin's paper on thermal noise.
phi = 1*10^{7} (loss angle)
r0 = 1.56*10^{2 }(beam radius)
T = 300 K (temperature)
E0 = 7.18*10^{10 } (Young's modulus)
sigma = 0.16 (Poisson ratio)
The value of S_{x}(100) that given in Levin's paper (8.7*10^{40} m^{2} /Hz) while the LiuThorne value is 9.1*10^{40} m^{2} /Hz.

Attachment 1: Levin_throne_comparison.pdf


11

Wed Jun 5 20:39:48 2013 
Deep Chatterjee  Optics  General  Conventional Thermal noise (Sec V) from Liu & Thorne  >The linearized PSD plots are created for the case of thermal noise in finite test mass (Sec. V) of Liu and Thorne.
S = 8*kb*T*phi*(U0 + delta_U)/omega
>The maximum energy due to stress is considered by an infinite sum here. A comparison has been made regarding the convergence of the sum.
>The two plots correspond to the cases of considering 10 and 100 terms in the sum respectively.
>The plot shows that the difference is not much and hence convergence is fast.
>The relative difference is plotted w.r.t S_100, the PSD considering 100 terms in the sum.
>The relative difference goes like abs(S_100  S_10)/S_100, where 10 and 100 represent the number of terms considered in the sum.
>The algorithm used to evaluate the sum involving Bessel functions was the one by GWINC. (http://nodus.ligo.caltech.edu:8080/COMSOL/10). 
Attachment 3: Thorne_thermal_noise.pdf


Attachment 4: Percentage_difference.pdf


12

Wed Jun 5 20:54:59 2013 
Deep Chatterjee  General  General  Bessel Function roots  During the process of evaluating the PSD from Sec. V of Liu and Thorn, I chanced to write a simpler root finding algorithm applying bisection to find the roots of J1(x).
The difference between this and the algorithm by
Greg von Winckel goes as
The difference is of the order 10^{7} and can be reduced by reducing the tolerance. However, It should however be noted that bisection is a crude algorithm for rough usage and differences become pronounced for larger n.

Attachment 2: bessel_zeros.m

function X = bessel_zeros(k, n)
%BESSEL_ZEROS : calculates the first k zeros of the bessel function Jn
% k : No. of ROOTS to be evaluated
% n : Order of the Bessel function Jn
% X : stores the roots in serial order i.e. X(1) gives the first root,
% X(2) gives the second and so on
X = zeros(1,k);% empty array of lenght k
count = 1;%this acts as a counter to k
dx = 0.1;%step size within which, by assumption, no roots exist
x = 0;
... 22 more lines ...

14

Thu Jun 6 17:00:11 2013 
Deep Chatterjee  Optics  General  Comparison of ITM and FTM geometries (FIG. 3 Liu & Thorne)  In section V of their paper on thermoelastic and homogenous thermal noise, Liu and Thorne have corrected the result of power spectral density of a Finite Test Mass from the result of BHV. Although the result of the infinte test mass has a closed form solution, that for the finite test mass is not closed and has to be approximated numerically. From the infinite series (Eq. (56), Eq.(57)) 100 terms were taken to approximate the sum. Considering that the convergence is fast (my last ELOG entry has a plot which shows little difference between considering 10 and 100 terms), 100 terms are a fair approximation.
The spectral density of thermal noise in the finite cavity is slightly lower than the corresponding infinite case. To highlight the difference between the two, they have plotted a quantity C_FTM which is a ratio of the linearized spectral densities of the Finite Test Mass and the Infinite Test Mass.
In this post, the same quantity has been numerically computed and plotted.
The above plot maybe compared to the one given on Fig. 3 of Liu & Thorne. Here r0 is the beam spot radius and CFTM is the quantity mentioned previously. A snapshot of the figure from Liu & Thorne is shown below
The match between the figures seem fair.
Since C_FTM is a ratio, its frequency independent (both S_ITM and S_FTM have 1/f dependence on frequency which cancels on taking the ratio). This is verified in the above plot where plots are made for 10, 100 and 1000 Hz and they fairly coincide. 
Attachment 2: C_FTM.pdf


Attachment 3: Fig3_Liu&Thorn.bmp

15

Fri Jun 7 17:41:41 2013 
Deep Chatterjee  General  General  Disscussion of the code of a 'comsol with matlab' model file  In this post the matlab code to build a model using COMSOL with matlab is analyzed from Koji Arai's codes on the calculation of TR noise in the 1D axisymmetric case. The post primarily describes the various commands used to interface with COMSOL.
It should be noted that the matlab script analyzed here is not the master script that will perform the simulation. The "main" file is called the "Main_thermo_refracive.m" found in the SVN repository TR noise_comsol
>The main script defines a structure called 'param' which stores all the parameters including the material properties and those related to running the simulation in comsol. This structure 'param' is hence passed on as arguments to all the other functions (in the SVN rep)
that compute the analytical solution or the COMSOL simulations.
>The part of the code ( the second if...end block) in "Main_thermo_refracive.m" that calls the COMSOL simulations, calls the function "thermo_refractive_COMSOL_1D_axisymmetric".
>In this function, the parameters are extracted from the structure 'param' and stored in separate variables. The time step in the simulation, the end time, mirror radius are defined and the function
that generates the model "thermo_refractive_COMSOL_1D_axisymmetric_model" is called which prepares the model in COMSOL.
> it should be noted that it is much of much ease to the user to define a simple model in COMSOL and export it in Matlab and then analyzed the same.
I had created a simple such file which a simple 3D metal bar is created and added some physics and study to see how the matlab file.
I have attached the same which also describes the relevant packages and subroutines in the comments. However, I had not erased the COMSOL history before the export hence it has significant amount of superfluous code. One may however have a look at the same

>The first thing done by the model builiding function is that it extracts a few parameters and stores them in separate variables in the first lines
f_mod = param.COMSOL.simulation_modulation_freq;
dt = param.COMSOL.simulation_time_step;
t_end = param.COMSOL.simulation_end_time;
>Since COMSOL accepts string arguments, the time steps are defined as a string
trange = ['range(0,' num2str(dt) ',' num2str(t_end) ')'];
**There is however a query regarding the keyword range which in Matlab returns the difference between the maximum and minimum of the list passed to it. range() passed to COMSOL would probably create an array fro 0  t_end in steps of dt.
The above line converts the quantity 'dt' and 't_end' to a string and concatenates it along with the rest of the string to make a valid string that would be understood by COMSOL.
>The COMSOL class is called next by the following two import statements (after a series of displays on the screen showing the status of the simulation).
>Managing models( like creation and destruction) is handled by the modelUtil class in COMSOL with Matlab and hence to create a model modelUtil.create() is called. "model.remove()" is used to destroy one such object. Line 29 says 
model = ModelUtil.create('Model');
>The above statement created an object called 'model' in Matlab and and a model in COMSOL by the name of 'Model'. The various attributes of this object is defined by the next few statements. Like,
[line 31]  model.name('thermo_refractive_COMSOL_1D_axisymmetric_model.mph');
The above statement assigns the filename of this COMSOL model created. Note that, since in Matlab, the Matlab object 'model' is used to invoke the functions i.e. 'model.name()' and not 'Model.name()'.
> The 'model.param' contains all functions related to setting and describing the parameters in the model.
*Note that the 'param' following keyword 'model' connected by the '.' has nothing to do with the 'param' structure used in the script "Main_thermo_refracive.m" which have been named anything else
> Now the model.param.set(<P>,<expr>) is used to give the parameter P an expression expr both being string.
The model.param.descr(<P>,<des>) has the same format but gives the description of the parameter P as des (something that is understandable in common terms).
This can be understood in the statements in [line 46  51]
model.param.set('beam_shape', '2/(pi*beam_size^2)*exp(2*r^2/beam_size^2)');
model.param.descr('beam_shape', '');
model.param.set('beam_intensity', 'beam_power*beam_shape');
model.param.descr('beam_intensity', '');
model.param.set('dT', 'mod1.TT_amb');
model.param.descr('dT', '');
An empty quote in the description implies that no description is given. The above statements define the parameters mentioned alongside them according to Heinerts paper.
> [line 5361]. the string 'var1' is used to tag all the global variables that are created. variables are expressions created out of the parameters.
Just like the above case, 'set()' is used to create variables and give them an expression, here as one can see 4 variables are created T_amb, beam_size, beam_power. and f_mod.
model.variable.create('var1');
model.variable('var1').set('T_amb', [num2str(param.material.temperature) '[K]']);
model.variable('var1').descr('T_amb', '');
model.variable('var1').set('beam_size', [num2str(param.beam.radius) '[m]']);
model.variable('var1').descr('beam_size', '');
model.variable('var1').set('beam_power', [num2str(param.COMSOL.beam_power) '[W]']);
model.variable('var1').descr('beam_power', '');
model.variable('var1').set('fmod', num2str(f_mod));
model.variable('var1').descr('fmod', '');
> The next section deals with the geometry. In this case the model is a 1D axisymmetric model. Hence one has the the digit 1 which specifies the dimension and axisymmetric is set to 'true'
model.geom.create('geom1', 1);
model.geom('geom1').axisymmetric(true);
> The run() function is to build the geometry
model.geom('geom1').run;
> The 'Interval' feature is present in the case of 1D models. The following line creates an interval feature called 'i1'
model.geom('geom1').feature.create('i1', 'Interval');
model.geom('geom1').feature('i1').set('p2', num2str(param.mirror.radius));
The above line is used to set the value of the right endpoint as the radius of the mirror. The string 'p2' is used to denote the right end point..
So this step creates a cylinder of radius equal to the radius of the mirror. In case of an infinite mirror an extra interval is added from the the radius to twice the radius.
It would help if more description on "interval" is left as comments and on why the extra interval was added and how does it make the calculation different.
> The interval is run using the 'run()' command.
> The material definition is added in the following section. Probably the data seems to have been taken from an external file rather than the COMSOL material library. Details of the file would be of help from the author.
The following lines cannot be understood. Comsol help on"propertyGroup" gives no results found
model.material('mat1').propertyGroup('def').set('heatcapacity', [num2str(param.material.specific_heat_per_volume) '[J/(kg*K)]']);
model.material('mat1').propertyGroup('def').set('density', [num2str(param.material.density) '[kg/m^3]']);
model.material('mat1').propertyGroup('def').set('thermalconductivity', [num2str(param.material.thermal_conductivity) '[W/(m*K)]']);
> The meshing is done on auto.
> As far as the Physics is concerned i.e. what kind of results we expect out of this geometry, the 'HeatTransfer' is selected.
A 1D heat source is created called 'hs1'
model.physics('ht').feature.create('hs1', 'HeatSource', 1);
and the Heat Source is time varying and given by beam_intensity*sin(2*fmod*pi*t). This can be seen in lines 121122
model.physics('ht').feature('hs1').selection.set([1]);
model.physics('ht').feature('hs1').set('Q', 1, 'beam_intensity*sin(2*fmod*pi*t)');
> If the mirror is infinite, something called 'InfiniteElements' is applied to the outer interval. More details on "infiniteElements" and why was it used would be helpful.
> A study involving the feature "Transient" was used. However, it is required to know what study was implemented from the GUI since the term "Transient" was not found under Study Steps in the GUI
> The time step tweaking of COMSOL is stopped by the following line 166
model.sol('sol1').feature('t1').set('tstepsbdf', 'strict');

Attachment 1: Iron_Bar_test1_model.m

function out = model
%
% Iron_Bar_test1_model.m
%
% Model exported on Jun 10 2013, 10:13 by COMSOL 4.3.0.151.
% This is an exported file from COMSOL in the '.m' format. I am adding
% comments to the lines.
% As one goes along the steps one followed in COMSOL and the corrsponding
% Matlab file, the purpose of the various subroutines become clear. The
... 430 more lines ...

17

Tue Jun 11 10:21:05 2013 
Deep Chatterjee  General  General  Re: Disscussion of the code of a 'comsol with matlab' model file 
Quote: 
In this post the matlab code to build a model using COMSOL with matlab is analyzed from Koji Arai's codes on the calculation of TR noise in the 1D axisymmetric case. The post primarily describes the various commands used to interface with COMSOL.
It should be noted that the matlab script analyzed here is not the master script that will perform the simulation. The "main" file is called the "Main_thermo_refracive.m" found in the SVN repository TR noise_comsol
>The main script defines a structure called 'param' which stores all the parameters including the material properties and those related to running the simulation in comsol. This structure 'param' is hence passed on as arguments to all the other functions (in the SVN rep)
that compute the analytical solution or the COMSOL simulations.
>The part of the code ( the second if...end block) in "Main_thermo_refracive.m" that calls the COMSOL simulations, calls the function "thermo_refractive_COMSOL_1D_axisymmetric".
>In this function, the parameters are extracted from the structure 'param' and stored in separate variables. The time step in the simulation, the end time, mirror radius are defined and the function
that generates the model "thermo_refractive_COMSOL_1D_axisymmetric_model" is called which prepares the model in COMSOL.
> it should be noted that it is much of much ease to the user to define a simple model in COMSOL and export it in Matlab and then analyzed the same.
I had created a simple such file which a simple 3D metal bar is created and added some physics and study to see how the matlab file.
I have attached the same which also describes the relevant packages and subroutines in the comments. However, I had not erased the COMSOL history before the export hence it has significant amount of superfluous code. One may however have a look at the same

>The first thing done by the model builiding function is that it extracts a few parameters and stores them in separate variables in the first lines
f_mod = param.COMSOL.simulation_modulation_freq;
dt = param.COMSOL.simulation_time_step;
t_end = param.COMSOL.simulation_end_time;
>Since COMSOL accepts string arguments, the time steps are defined as a string
trange = ['range(0,' num2str(dt) ',' num2str(t_end) ')'];
**There is however a query regarding the keyword range which in Matlab returns the difference between the maximum and minimum of the list passed to it. range() passed to COMSOL would probably create an array fro 0  t_end in steps of dt.
The above line converts the quantity 'dt' and 't_end' to a string and concatenates it along with the rest of the string to make a valid string that would be understood by COMSOL.
>The COMSOL class is called next by the following two import statements (after a series of displays on the screen showing the status of the simulation).
>Managing models( like creation and destruction) is handled by the modelUtil class in COMSOL with Matlab and hence to create a model modelUtil.create() is called. "model.remove()" is used to destroy one such object. Line 29 says 
model = ModelUtil.create('Model');
>The above statement created an object called 'model' in Matlab and and a model in COMSOL by the name of 'Model'. The various attributes of this object is defined by the next few statements. Like,
[line 31]  model.name('thermo_refractive_COMSOL_1D_axisymmetric_model.mph');
The above statement assigns the filename of this COMSOL model created. Note that, since in Matlab, the Matlab object 'model' is used to invoke the functions i.e. 'model.name()' and not 'Model.name()'.
> The 'model.param' contains all functions related to setting and describing the parameters in the model.
*Note that the 'param' following keyword 'model' connected by the '.' has nothing to do with the 'param' structure used in the script "Main_thermo_refracive.m" which have been named anything else
> Now the model.param.set(<P>,<expr>) is used to give the parameter P an expression expr both being string.
The model.param.descr(<P>,<des>) has the same format but gives the description of the parameter P as des (something that is understandable in common terms).
This can be understood in the statements in [line 46  51]
model.param.set('beam_shape', '2/(pi*beam_size^2)*exp(2*r^2/beam_size^2)');
model.param.descr('beam_shape', '');
model.param.set('beam_intensity', 'beam_power*beam_shape');
model.param.descr('beam_intensity', '');
model.param.set('dT', 'mod1.TT_amb');
model.param.descr('dT', '');
An empty quote in the description implies that no description is given. The above statements define the parameters mentioned alongside them according to Heinerts paper.
> [line 5361]. the string 'var1' is used to tag all the global variables that are created. variables are expressions created out of the parameters.
Just like the above case, 'set()' is used to create variables and give them an expression, here as one can see 4 variables are created T_amb, beam_size, beam_power. and f_mod.
model.variable.create('var1');
model.variable('var1').set('T_amb', [num2str(param.material.temperature) '[K]']);
model.variable('var1').descr('T_amb', '');
model.variable('var1').set('beam_size', [num2str(param.beam.radius) '[m]']);
model.variable('var1').descr('beam_size', '');
model.variable('var1').set('beam_power', [num2str(param.COMSOL.beam_power) '[W]']);
model.variable('var1').descr('beam_power', '');
model.variable('var1').set('fmod', num2str(f_mod));
model.variable('var1').descr('fmod', '');
> The next section deals with the geometry. In this case the model is a 1D axisymmetric model. Hence one has the the digit 1 which specifies the dimension and axisymmetric is set to 'true'
model.geom.create('geom1', 1);
model.geom('geom1').axisymmetric(true);
> The run() function is to build the geometry
model.geom('geom1').run;
> The 'Interval' feature is present in the case of 1D models. The following line creates an interval feature called 'i1'
model.geom('geom1').feature.create('i1', 'Interval');
model.geom('geom1').feature('i1').set('p2', num2str(param.mirror.radius));
The above line is used to set the value of the right endpoint as the radius of the mirror. The string 'p2' is used to denote the right end point..
So this step creates a cylinder of radius equal to the radius of the mirror. In case of an infinite mirror an extra interval is added from the the radius to twice the radius.
It would help if more description on "interval" is left as comments and on why the extra interval was added and how does it make the calculation different.
> The interval is run using the 'run()' command.
> The material definition is added in the following section. Probably the data seems to have been taken from an external file rather than the COMSOL material library. Details of the file would be of help from the author.
The following lines cannot be understood. Comsol help on"propertyGroup" gives no results found
model.material('mat1').propertyGroup('def').set('heatcapacity', [num2str(param.material.specific_heat_per_volume) '[J/(kg*K)]']);
model.material('mat1').propertyGroup('def').set('density', [num2str(param.material.density) '[kg/m^3]']);
model.material('mat1').propertyGroup('def').set('thermalconductivity', [num2str(param.material.thermal_conductivity) '[W/(m*K)]']);
> The meshing is done on auto.
> As far as the Physics is concerned i.e. what kind of results we expect out of this geometry, the 'HeatTransfer' is selected.
A 1D heat source is created called 'hs1'
model.physics('ht').feature.create('hs1', 'HeatSource', 1);
and the Heat Source is time varying and given by beam_intensity*sin(2*fmod*pi*t). This can be seen in lines 121122
model.physics('ht').feature('hs1').selection.set([1]);
model.physics('ht').feature('hs1').set('Q', 1, 'beam_intensity*sin(2*fmod*pi*t)');
> If the mirror is infinite, something called 'InfiniteElements' is applied to the outer interval. More details on "infiniteElements" and why was it used would be helpful.
> A study involving the feature "Transient" was used. However, it is required to know what study was implemented from the GUI since the term "Transient" was not found under Study Steps in the GUI
model.study('std1').feature.create('time', 'Transient'); [line 134]
> The time step tweaking of COMSOL is stopped by the following line 166
model.sol('sol1').feature('t1').set('tstepsbdf', 'strict');

**The point where the feature called 'Transient' is spoken about  By selecting 'Time Dependent' under the 'Study' in COMSOL desktop, the line that gets added to the Matlab script.
So it was the 'Time Dependent' feature that was selected while creating the model 
18

Tue Jun 11 17:04:33 2013 
Deep Chatterjee  General  General  Analyzing the file 'thermo_refractive_COMSOL_1D_axisymmetric' by Koji Arai  The file 'thermo_refractive_COMSOL_1D_axisymmetric.m' found in the SVN repository https://nodus.ligo.caltech.edu:30889/svn/trunk/comsol/thermorefractive/ performs the data extraction from the COMSOL simulation
and computes quantities as given in Heinert's paper.
This is the where the dissipation is calculated from the temperature gradient and the use of FDT is made to evaluate the linearized PSD.

The first few lines of the code extracts the variable values out of the structure 'param' and stores it in new variables for the ease of coding.
The important portion comes in with the iterative structure (for loop) in line 29.
A point wise summary of the steps done would be as follows 
* The finite elements in space and time are defined in the arrays r0 and t0 according to the time and radial slice steps dt and dR until R, the radius and the t_end, the time until which simulation runs
* A matrix called dat is created which is used to store the values of the temperature gradient as returned by COMSOL.
It stores the values as a function of r along the columns and as a function of t along the rows.
Thus, moving vertically down the matrix in a column would give the values of the temperature gradient for a fixed r as a function of t
* Two other row vectors datrabs and datrphs having lengths of the array r0 are used to store the values of the square of the Fourier coefficients and the phase angle.
* The extraction of data from COMSOL is done in the lines 7174
for i2=1:length(t0)
tmp = mphinterp(model,'ht.gradTr','coord',r0,'T',t0(i2));
dat(:,i2) = tmp;
end
* After the above step, the matrix dat is filled with the values of the temperature gradient as mentioned previously.
* Next to evaluate to the Fourier coefficients, the second half of the simulation time is used. Probably to let the transients die down as mentioned in the ELOG post by the author.
* To find out the Fourier components, we multiply the desired function by sin(omega*t) or cos(omega*t) and integrate over the period of the function. There is also a prefactor of 1/L where L is the length of the period
over which the function is defined.
* To do the above exercise, the sine and cosine of omega*t is separately evaluated and stored in skernel and ckernel. Note that the time interval as mentioned above is the second half of the simulation time.
* Now for all the radial slices, the Fourier coefficients are extracted using the statements in for loop in line 83
for i2=1:length(r0)
tseries=detrend(dat(i2,(length(t0)+1)/2:length(t0)));
tmp1=mean(tseries.*skernel);
tmp2=mean(tseries.*ckernel);
datrabs(i2)=2*sqrt(tmp1^2+tmp2^2);
datrphs(i2)=atan2(tmp2,tmp1)/pi*180;
end
Using the definition of mean of a function ' f ' in the continuous case as f_mean = integral{ f(t)dt} / integral{ dt } , over the values of t
tmp1 has used ' f ' as tseries.*skernel which means that one multiplies the time signal with sin(omega*t) and integrates. tmp2 has used cosine instead
Thus, tmp1 and tmp2 are the Fourier coefficients of tseries at the frequency fmod defined right close to the first for loop in line 29.
* The coefficients are squared and added in the line 88
datrabs(i2)=2*sqrt(tmp1^2+tmp2^2);
This quantity how much of the frequency ' fmod' is present in the time signal.
datrphs stores the same for the phase shift phi. Note however, all of this is done as a function of r. The plotting is done in the following lines. Note that while running the code, as a result, the plots are seen to
get updated each time the loop [line 29] iterates.
* Following this, is the part where W_diss, the dissipation is calculated using formula [The expression used does not match Eq. 15 in Heinert's. Any comments regarding the formula used for W_diss are welcome].
The heinert's eq(15) goes as  W_diss = pi*H*kappa/T0 * integral{ grad_T^2 * rdr }
The quantity datrabs is squared and the integral mentioned above is calculated w.r.t. r using the trapz algorithm from Matlab.
The value for each frequency i.e. each 'fmod' is converted to a string and displayed on screen.
* The reason why the grad_T was changed to its frequency domain before integration is suspected to be something related to the Parseval's Theorem. However, more details or correction on the same is welcome. 
19

Wed Jun 12 13:52:44 2013 
Deep Chatterjee  Optics  General  Difference in COMSOL and Analytic solution for TR noise  In this post, I am reporting of the relative difference between the analytic and COMSOL results.
The file by the name 'Main_thermo_refractive.m' found in the SVN was slightly modified to generate the difference plot.
The quantity plotted is the absolute value of the difference between the two results divided by the result given by COMSOL.
The plot is in a semilogx plot. It can be seen the maximum deviation goes to a maximum of 6%.
Also the difference is higher at the higher frequencies.
The plot shows two cases  the case for which 500 terms in the series were summed to get the analytic solution and second
is the case where 1000 terms were summed. The plot does not change much due to the number of terms being summed
showing that the convergence is fast.

25

Thu Jun 20 12:41:01 2013 
Deep Chatterjee  General  General  The expression for the "work dissipated" in the TE and TR noise calculations  While discussing TE noise with Yanbei Chen, it was realized that the expression for the work dissipated W_diss was derivable from the inhomogenous Heat equation with a source term.
The exercise was tried out to some success and can be found in the attachment. The attachment describes the steps roughly.
The important point to note is the fact that while Liu and Thorne considered stresses developed in the material by means of the heat balance equation, they have ultimately resorted to the
expression for W_diss = 1/T * integral{ kappa * grad(T)^2 rdr } to calculate the dissipation. They have used an expression whch relates the expansion, Theta, to the gradient of temperature.
It is suspected that the fundamental approach is to consider a source of heat and evaluating the dissipation. However, Liu and Thorne considered applying pressure probably because of the
physical scenario of the fluctuations in the mirror face.
Discussion over the same would be helpful. 
Attachment 1: dissipated_work.pdf


27

Thu Jun 20 16:29:38 2013 
Deep Chatterjee  Optics  General  Differences on using a coarser mesh in calculating TR noise  In the code for evaluating TR noise, the parameter for automatic meshing (which can take values from 1 to 9  1 being the finest and 9 the coarsest mesh) was changed from 1 to 5 and 9.
The computation time surprisingly doesn't differ much. The maximum relative error also stays close to 6% as in the case of the finest mesh. The relative difference for two cases for a mesh
number of 5 and 9 are shown in the attachment.
The conclusion being that it is better to stick to the mesh number 1 which is the finest mesh.

31

Mon Jun 24 18:00:26 2013 
Deep Chatterjee  Optics  General  The problem of TE Noise calculation for a beam passing through a cylindrical substrate  In this post, I mention of my immediate plan for the week and also describe the problem I am looking at in brief.
In the calculation of TR noise for the beam passing through a cylindrical substrate, Heinert has considered thermal fluctuations
by means of an sinusoidally oscillating heat source, scaled according to the intensity profile of the beam, present along the length of the cylinder.
The heat equation is then solved to evaluate the temperature field. The gradient of temperature is used to calculate the work dissipated.
The work dissipated then is used to find the spectral density according to the Fluctuation Dissipation Theorem.
On the other had, the case of TE noise is considered in the work by Liu and Thorne where the beam reflecting from one of the faces is
considered. In their work, they have used an oscillating pressure, scaled according to the beam, at the face. The equation of stress balance
is solved to get the strain field, the strain results in heating and as a result, a temperature gradient. The work dissipated is calculated using
the gradient of temperature and the spectral density is calculated using the FDT.
Now, in case of Heinert's work, it is to be noted that the heating term is the one that contains the TR coefficient, beta = dn/dT. This is the where
the TR noise that we are looking into comes in the picture. Liu and Thorne's work on the other had, never has an explicit heat source. In their case,
it is the strain that generates the heat implicitly. They have related the expansion with the temperature perturbation in their paper from an expression
in Landau Lifshitz's, Theory of Elasticity. The important point to note is that the physical parameters that characterize the TE noise like coefficient of
linear expansion, alpha, or Poisson ratio, sigma, come into the picture through this relation. Another point to note is that the expression
for the work dissipated ( W_diss ) uses the gradient of temperature( It is the same formula that Heinert has used). This expression is derivable from the heat
equation. Thus, one could have also done the exercise by injecting the right heat source and solving the heat equation instead, since its ultimately
fluctuations in temperature that cause these noises TR or TE.
Our problem is to evaluate TE noise for a beam that passes through the cylindrical substrate instead of reflection off the face. It is suspected that using an
oscillating pressure on the surface will not be the correct approach since the beam is going through the material and not just reflecting from the surface. We
want to solve it by means of a heat injection, as done in Heinert, calculating the gradient of temperature, the work dissipated and then the spectral density. It is realized that the
heat source should be oscillating but the correct coefficients is what is undetermined i.e. we realize the heat source is q_dot = [  ] * cos(omega * t) . In case
of Heinert it is at this point that the 'beta' comes in. However, in the TE case this is not yet determined. The literature doesn't deal with the case of beam goin through
a material. The equations in Heinert must be looked at more deeply to realize how the 'beta' comes in and then drawing an analogy, we may be able to figure out the
right heat source for the TE noise case.
Any comments on references, the approach that should be taken, or any thoughts on the problem is most welcome. 
41

Fri Jun 28 14:03:07 2013 
Deep Chatterjee  General  General  Approach for TE noise for beam in cavity  In this post I mention of the approach that would be taken to solve for the TE noise spectrum for a beam inside the substrate cavity.
Completing the same would be my plan for the next week.
In the COMSOL simulation, a gaussian pressure will be applied on both the flat surface of the cylinder. The strain would be calculated
using the Structural mechanics module and the temperature field would be calculated using the Heat Transfer module. The approach
is similar to that followed in Liu and Thorne. The Work dissipated would be calculated using the gradient of T. The spectral density is
then calculated using the FDT.
In the attachment, I have written briefly about the material I have studied this week along with my thoughts on the problem of the TE noise
calculation. 
Attachment 1: LL_derivations.pdf


46

Thu Jul 4 15:23:47 2013 
Deep Chatterjee  Optics  General  Attempt to compute TE noise following Liu and Thorne  Liu and Thorne, in their paper have analytically solved for the TE noise spectra considering the test mass to be a half infinite space.
An attempt was made to get similar results using a COMSOL model. In this post, the rough profile of the PSD plot is given and is compared
to Liu and Thorne's result.
Steps followed by Liu and Thorne:
> Oscillating pressure, scaled according to beam profile, is applied one of the surfaces.
> The stress balance equation is solved borrowing algorithm from Landau Lifshitz.
> The stress and the temperature perturbation is related using an equation given in Chapter 1 of LL
> The W_diss is calculated from the gradient of the temperature.
> PSD is calculated using FDT due to Levin
> The resulting plot looks like the following  ***Only the frequency dependence is plotted here leaving out the prefactors which will
appear just as an additive constant in the figure. The aim was to see how the plot of the simulation looks like.
Steps followed in the COMSOL model:
> 2D axisymmetric model was used since the applied was applied radially symmetrically.
> The dimensions of the test mass(cylinder) was defined larger as compared to the beam spot radius.
> The physics added was Solid Stress and Heat Transfer in Solids.
> Thermal expansion was enabled in the Solid Stress physics
> Pressure work was enabled in Heat Transfer physics which takes into consideration heat due to stresses i.e. adds this heat source to the heat eqn
> Heat insulation wsa applied to all surfaces.
> All surfaces apart from the one where pressure was applied was held fixed to mimic infinity
> A custom mesh was put.
> The model was exported as '.m'
> It was called for frequency range 10^(0 : 0.25 : 4)
> Following Liu and Thorne, the temperature gradient was integrated over the volume using mphint2() function in Matlab
> The time average was taken over the second half of the cycle to avoid transient which are assumed to die off after a couple of initial cycles.
> All the prefactors were ignored while plotting
> The plot shown below is integral{grad_T}^2} / omega^2 which is proportional to PSD
> We just wanted to see if at all we got anything looking similar to the analytic result of Liu and Thorne (shown above)
The above plot is when the radius is 100 times the beam spot and height of the cylinder is 200 times the beam spot
Other values of radius and height were also tried. The one below shows similar plot as above but for radius 10 times
the beam spot and height 20 times the same
While the one below is for radius = 1000 * beam spot and height = 2000 * beam spot
Here, it is seen that the straight line with a negative slope is seen to some extent.
However, the prefactors, when put in, will show the actual PSD.
Any comments or suggestions related to the model construction in COMSOL or otherwise is welcome. 
Attachment 1: Liu&Thorne_type.bmp

Attachment 5: 2D_almost_infinte_TE.mph

47

Fri Jul 5 14:06:24 2013 
Deep Chatterjee  Optics  General  Attempt to compute TE noise following Liu and Thorne 
Quote: 
Liu and Thorne, in their paper have analytically solved for the TE noise spectra considering the test mass to be a half infinite space.
An attempt was made to get similar results using a COMSOL model. In this post, the rough profile of the PSD plot is given and is compared
to Liu and Thorne's result.
Steps followed by Liu and Thorne:
> Oscillating pressure, scaled according to beam profile, is applied one of the surfaces.
> The stress balance equation is solved borrowing algorithm from Landau Lifshitz.
> The stress and the temperature perturbation is related using an equation given in Chapter 1 of LL
> The W_diss is calculated from the gradient of the temperature.
> PSD is calculated using FDT due to Levin
> The resulting plot looks like the following  ***Only the frequency dependence is plotted here leaving out the prefactors which will
appear just as an additive constant in the figure. The aim was to see how the plot of the simulation looks like.
Steps followed in the COMSOL model:
> 2D axisymmetric model was used since the applied was applied radially symmetrically.
> The dimensions of the test mass(cylinder) was defined larger as compared to the beam spot radius.
> The physics added was Solid Stress and Heat Transfer in Solids.
> Thermal expansion was enabled in the Solid Stress physics
> Pressure work was enabled in Heat Transfer physics which takes into consideration heat due to stresses i.e. adds this heat source to the heat eqn
> Heat insulation wsa applied to all surfaces.
> All surfaces apart from the one where pressure was applied was held fixed to mimic infinity
> A custom mesh was put.
> The model was exported as '.m'
> It was called for frequency range 10^(0 : 0.25 : 4)
> Following Liu and Thorne, the temperature gradient was integrated over the volume using mphint2() function in Matlab
> The time average was taken over the second half of the cycle to avoid transient which are assumed to die off after a couple of initial cycles.
> All the prefactors were ignored while plotting
> The plot shown below is integral{grad_T}^2} / omega^2 which is proportional to PSD
> We just wanted to see if at all we got anything looking similar to the analytic result of Liu and Thorne (shown above)
The above plot is when the radius is 100 times the beam spot and height of the cylinder is 200 times the beam spot
Other values of radius and height were also tried. The one below shows similar plot as above but for radius 10 times
the beam spot and height 20 times the same
While the one below is for radius = 1000 * beam spot and height = 2000 * beam spot
Here, it is seen that the straight line with a negative slope is seen to some extent.
However, the prefactors, when put in, will show the actual PSD.
Any comments or suggestions related to the model construction in COMSOL or otherwise is welcome.

Here is a plot showing the profiles of Liu and Thorne and the COMSOL simulation. Since the constants were not taken into account, one expects the plot to be shifted by a constant equal to the logarithm of the prefactor that has been ignored.
The green 'o' is just a 1/omega^2 plot in the loglog scale which is how Liu and Thorne's result go (this is not linearized PSD, but is doesn't matter as long as we want to see the profiles). The other plot in blue is the COMSOL simulation.
The plot below is a difference between them. One expects it to be a constant but there are a few jitters. Once again, it is emphasized that the numerical values do not give any information related to the actual difference which will only be calculable
once the correct physical constants are put in the formula. I will post another entry once that is done

Attachment 2: L&T_COMSOL_difference.bmp

54

Thu Jul 11 19:16:12 2013 
Deep Chatterjee  General  General  TE noise problem  Matlab script  The present aim is the calculation of the TE noise like Liu and Thorne. Although, the results of Liu and Thorne are for the case of an infinite mirror, in our case, we try
to model a test mass with large dimensions in an attempt to get closer to the result due to Liu and Thorne
Following my previous post  The presents results given by the COMSOL simulations gave the same profile as Liu and Thorne's result which has a frequency dependence
of 1/omega^2 but was displaced from the analytic result by a constant factor which was dependent on the applied pressure on the face of the test mass which should not be
the case.
Following the steps followed Liu and Thorne, we had constructed the test mass as a cylinder, large compared to the beam spot size. An oscillating pressure was applied
to one of the faces and the from the temperature gradient generated in the process due to strains, one can calculate the work dissipated. The process involves integrating
the gradient of temperature over the entire geometry and taking the time avrage. However, this did not give the correct results, so it was decide to extract the Fourier coefficient
of the signal and perform the integration on it, as done in the case of TR niose by Koji Arai.
I mention the steps it was done 
> The data extracted was stored in a 3D array in matlab. using mphinterp  each dimension for r, z, t
> The number of radial slices and z slices is defined by the user previously
> For each r,z value there was a time signal.
> The fourier coefficient corresponding to the pressure oscillation frequency was extracted from the last three cycles
(In theory only one cycle should suffice)
> The above step was done so that random data( which is small in magnitude) generated by COMSOL is avoided.
> The fourier coefficients are stored in a 2D array corresponding to r and z values.
> The integration was performed using trapz twice once on each dimension to get the total volume integral
> The rest of the calculation is same as the previous script  plugging in the prefactors in the formulae and plotting
**The primary problem with this script is that the data extraction takes significant amount of time  For a mirror with 200 times the radius of the beam spot and 200 radial slices, it takes close to 6 minutes
to evaluate work dissipated for each frequency. The script solves for 16 frequency values. The results for small number of radial slices does not follow the straight line profile. For larger number of slices
the program takes a longer time. The results have not been checked yet. 
Attachment 1: TE_model.m

% TE calculation using 2D axisymmetric model. This script calls the model
% file, extracts grad_T and does the calculations for the different
% frequency
% All parameter are defined in this script and passed to the COMSOL model
% via arguments
% Parameters, Quantitites in [m]
param.beam.radius = 0.05;
param.mirror.radius = 100 * param.beam.radius;
%Define the radius of the mirror as 100 times that of the beam radius
param.mirror.height = 200 * param.beam.radius;
... 94 more lines ...

Attachment 2: almost_infinite_2D_axisym_TE_4.m

function out = almost_infinite_2D_axisym_TE_4(param)
% Putting all the parameters in the variables
r0 = param.beam.radius;
R = param.mirror.radius;
H = param.mirror.height;
dt = param.COMSOL.simulation_time_step;
fmod = param.COMSOL.fmod;
t_end = param.COMSOL.simulation_end_time;
p0 = param.constant.F0/(pi*r0^2);% The amplitude of Osc. pressure
T_amb = param.constant.T_amb;
... 121 more lines ...

57

Fri Jul 12 19:43:32 2013 
Deep Chatterjee  General  General  TE noise problem  Matlab script 
Quote: 
The present aim is the calculation of the TE noise like Liu and Thorne. Although, the results of Liu and Thorne are for the case of an infinite mirror, in our case, we try
to model a test mass with large dimensions in an attempt to get closer to the result due to Liu and Thorne
Following my previous post  The presents results given by the COMSOL simulations gave the same profile as Liu and Thorne's result which has a frequency dependence
of 1/omega^2 but was displaced from the analytic result by a constant factor which was dependent on the applied pressure on the face of the test mass which should not be
the case.
Following the steps followed Liu and Thorne, we had constructed the test mass as a cylinder, large compared to the beam spot size. An oscillating pressure was applied
to one of the faces and the from the temperature gradient generated in the process due to strains, one can calculate the work dissipated. The process involves integrating
the gradient of temperature over the entire geometry and taking the time avrage. However, this did not give the correct results, so it was decide to extract the Fourier coefficient
of the signal and perform the integration on it, as done in the case of TR niose by Koji Arai.
I mention the steps it was done 
> The data extracted was stored in a 3D array in matlab. using mphinterp  each dimension for r, z, t
> The number of radial slices and z slices is defined by the user previously
> For each r,z value there was a time signal.
> The fourier coefficient corresponding to the pressure oscillation frequency was extracted from the last three cycles
(In theory only one cycle should suffice)
> The above step was done so that random data( which is small in magnitude) generated by COMSOL is avoided.
> The fourier coefficients are stored in a 2D array corresponding to r and z values.
> The integration was performed using trapz twice once on each dimension to get the total volume integral
> The rest of the calculation is same as the previous script  plugging in the prefactors in the formulae and plotting
**The primary problem with this script is that the data extraction takes significant amount of time  For a mirror with 200 times the radius of the beam spot and 200 radial slices, it takes close to 6 minutes
to evaluate work dissipated for each frequency. The script solves for 16 frequency values. The results for small number of radial slices does not follow the straight line profile. For larger number of slices
the program takes a longer time. The results have not been checked yet.

I am replying to report of the modification made to the script from the last one. The problem of too many radial and z slices have been avoided by using a slicing based on a gaussian
distribution both along the r and z directions  i.e. the slicing is heavy in the region around the surface is applied and much thinner towards the edges of the cylinder. The slicing has
been separately handled by a function named giveSlices() which does the slicing and returns the values as two arrays corresponding to r and z.
The extent to which the fineness of slicing is controlled in the geometry is by controlling the parameter SD in the code which is the standard deviation of the gaussian according to which
the slicing is controlled as being fine throughout or fine in the centre and thin with increasing r.
This method reduces the number of slices by almost 2 orders for significant large values of the dimensions of the test mass while it is expected to give similar results since slicing the
test mass finely at the edge is not required as the gradient of temperature almost falls to zero.
It is suspected that the long time of simulation is attributed to calling mphinterp() command a large number of times. In my next modification, it will be tried to use the command just once
followed by the proper data extraction from the output given by the command.

Attachment 1: codes_TE_calc.zip

58

Sun Jul 14 15:13:46 2013 
Deep Chatterjee  General  General  TE noise problem  Matlab script 
Quote: 
Quote: 
The present aim is the calculation of the TE noise like Liu and Thorne. Although, the results of Liu and Thorne are for the case of an infinite mirror, in our case, we try
to model a test mass with large dimensions in an attempt to get closer to the result due to Liu and Thorne
Following my previous post  The presents results given by the COMSOL simulations gave the same profile as Liu and Thorne's result which has a frequency dependence
of 1/omega^2 but was displaced from the analytic result by a constant factor which was dependent on the applied pressure on the face of the test mass which should not be
the case.
Following the steps followed Liu and Thorne, we had constructed the test mass as a cylinder, large compared to the beam spot size. An oscillating pressure was applied
to one of the faces and the from the temperature gradient generated in the process due to strains, one can calculate the work dissipated. The process involves integrating
the gradient of temperature over the entire geometry and taking the time avrage. However, this did not give the correct results, so it was decide to extract the Fourier coefficient
of the signal and perform the integration on it, as done in the case of TR niose by Koji Arai.
I mention the steps it was done 
> The data extracted was stored in a 3D array in matlab. using mphinterp  each dimension for r, z, t
> The number of radial slices and z slices is defined by the user previously
> For each r,z value there was a time signal.
> The fourier coefficient corresponding to the pressure oscillation frequency was extracted from the last three cycles
(In theory only one cycle should suffice)
> The above step was done so that random data( which is small in magnitude) generated by COMSOL is avoided.
> The fourier coefficients are stored in a 2D array corresponding to r and z values.
> The integration was performed using trapz twice once on each dimension to get the total volume integral
> The rest of the calculation is same as the previous script  plugging in the prefactors in the formulae and plotting
**The primary problem with this script is that the data extraction takes significant amount of time  For a mirror with 200 times the radius of the beam spot and 200 radial slices, it takes close to 6 minutes
to evaluate work dissipated for each frequency. The script solves for 16 frequency values. The results for small number of radial slices does not follow the straight line profile. For larger number of slices
the program takes a longer time. The results have not been checked yet.

I am replying to report of the modification made to the script from the last one. The problem of too many radial and z slices have been avoided by using a slicing based on a gaussian
distribution both along the r and z directions  i.e. the slicing is heavy in the region around the surface is applied and much thinner towards the edges of the cylinder. The slicing has
been separately handled by a function named giveSlices() which does the slicing and returns the values as two arrays corresponding to r and z.
The extent to which the fineness of slicing is controlled in the geometry is by controlling the parameter SD in the code which is the standard deviation of the gaussian according to which
the slicing is controlled as being fine throughout or fine in the centre and thin with increasing r.
This method reduces the number of slices by almost 2 orders for significant large values of the dimensions of the test mass while it is expected to give similar results since slicing the
test mass finely at the edge is not required as the gradient of temperature almost falls to zero.
It is suspected that the long time of simulation is attributed to calling mphinterp() command a large number of times. In my next modification, it will be tried to use the command just once
followed by the proper data extraction from the output given by the command.

Following the previous reply regarding the use of mphinterp(), the appropriate changes in code were made. The overhead time due to the call to COMSOL was responsible for the longer
simulation time. Right now, for relatively large no. of total slices (about 27000) just the extraction of data happens within a few seconds. However, for the larger number of slices, the codes
will probably still take some time to complete. The codes are attached. 
Attachment 1: codes_TE_calc_(2).zip

60

Mon Jul 15 16:05:29 2013 
Deep Chatterjee  General  General  TE noise problem  Matlab script 
Quote: 
Quote: 
Quote: 
The present aim is the calculation of the TE noise like Liu and Thorne. Although, the results of Liu and Thorne are for the case of an infinite mirror, in our case, we try
to model a test mass with large dimensions in an attempt to get closer to the result due to Liu and Thorne
Following my previous post  The presents results given by the COMSOL simulations gave the same profile as Liu and Thorne's result which has a frequency dependence
of 1/omega^2 but was displaced from the analytic result by a constant factor which was dependent on the applied pressure on the face of the test mass which should not be
the case.
Following the steps followed Liu and Thorne, we had constructed the test mass as a cylinder, large compared to the beam spot size. An oscillating pressure was applied
to one of the faces and the from the temperature gradient generated in the process due to strains, one can calculate the work dissipated. The process involves integrating
the gradient of temperature over the entire geometry and taking the time avrage. However, this did not give the correct results, so it was decide to extract the Fourier coefficient
of the signal and perform the integration on it, as done in the case of TR niose by Koji Arai.
I mention the steps it was done 
> The data extracted was stored in a 3D array in matlab. using mphinterp  each dimension for r, z, t
> The number of radial slices and z slices is defined by the user previously
> For each r,z value there was a time signal.
> The fourier coefficient corresponding to the pressure oscillation frequency was extracted from the last three cycles
(In theory only one cycle should suffice)
> The above step was done so that random data( which is small in magnitude) generated by COMSOL is avoided.
> The fourier coefficients are stored in a 2D array corresponding to r and z values.
> The integration was performed using trapz twice once on each dimension to get the total volume integral
> The rest of the calculation is same as the previous script  plugging in the prefactors in the formulae and plotting
**The primary problem with this script is that the data extraction takes significant amount of time  For a mirror with 200 times the radius of the beam spot and 200 radial slices, it takes close to 6 minutes
to evaluate work dissipated for each frequency. The script solves for 16 frequency values. The results for small number of radial slices does not follow the straight line profile. For larger number of slices
the program takes a longer time. The results have not been checked yet.

I am replying to report of the modification made to the script from the last one. The problem of too many radial and z slices have been avoided by using a slicing based on a gaussian
distribution both along the r and z directions  i.e. the slicing is heavy in the region around the surface is applied and much thinner towards the edges of the cylinder. The slicing has
been separately handled by a function named giveSlices() which does the slicing and returns the values as two arrays corresponding to r and z.
The extent to which the fineness of slicing is controlled in the geometry is by controlling the parameter SD in the code which is the standard deviation of the gaussian according to which
the slicing is controlled as being fine throughout or fine in the centre and thin with increasing r.
This method reduces the number of slices by almost 2 orders for significant large values of the dimensions of the test mass while it is expected to give similar results since slicing the
test mass finely at the edge is not required as the gradient of temperature almost falls to zero.
It is suspected that the long time of simulation is attributed to calling mphinterp() command a large number of times. In my next modification, it will be tried to use the command just once
followed by the proper data extraction from the output given by the command.

Following the previous reply regarding the use of mphinterp(), the appropriate changes in code were made. The overhead time due to the call to COMSOL was responsible for the longer
simulation time. Right now, for relatively large no. of total slices (about 27000) just the extraction of data happens within a few seconds. However, for the larger number of slices, the codes
will probably still take some time to complete. The codes are attached.

The dependence of the Power Spectral Density on the parameters F0, which is the pressure amplitude, has been somewhat corrected for in the codes attached. The mistake lay in the fact that
extraction of the Fourier coefficients was being done for the ht.gradTmag, the Fourier coefficients of which are not the correct ones to be used in this case since ht.gradTmag is not the correct time signal.
In the present case the Fourier coefficients are extracted from the r and z components, squared and added to carry out the calculation. However, the results are still off from the L&T results by order of 5.
The codes and the plots are attached.
The red values are the L&T result while the blue sketch is the simulation 
Attachment 1: codes_TE_calc.zip

61

Tue Jul 23 18:26:04 2013 
Deep Chatterjee  Optics  General  Comparison between Liu and Thorne Results and COMSOL results for TE noise  In this post I report of the results of TE noise simulated by COMSOL for the TE noise of Infinite test masses.
The aim was to follow the procedure by Liu and Thorne in their analytic calculations so that the same model could be used for the other
geometries.
The simulation is done in a different way than the TR simulations. It was observed that the output given by COMSOL by the use of commands
like mphinterp() or taking an export resulted in certain discrepancies between the results computed in COMSOL and that read by MATLAB.
Thus, the volume integration of the temperature gradient is performed in COMSOL itself and the results of the integration for each time
are sent to files. Matlab read these values and time averages them to get the result as in the paper (Sec. 2 of Liu and Thorne).
The errors expected are
> Fourier analysis is not done at all. This would have involved exporting data which, as mentioned before is giving errors
> The numerical errors by COMSOL are therefore not filtered off.
> The plot differs from the analytic solution for larger frequencies over 3000 Hz.
> It is to be noted from the paper by Liu and Thorne that the TE noise for the finite and infinite case are not very different. In
fact the correction factor goes as O(1). Thus, differences between finite and inifinte cases are unlikely to be prominent
in the log scale plots
The codes are put as a zip file. Corrections made to the codes will be uploaded as a reply.

Attachment 2: TE_calc_Jul23.zip

Attachment 3: Jul_23.eps


67

Tue Jul 23 20:53:37 2013 
Deep Chatterjee  Optics  General  Comparison between Liu and Thorne Results and COMSOL results for TE noise 
Quote: 
In this post I report of the results of TE noise simulated by COMSOL for the TE noise of Infinite test masses.
The aim was to follow the procedure by Liu and Thorne in their analytic calculations so that the same model could be used for the other
geometries.
The simulation is done in a different way than the TR simulations. It was observed that the output given by COMSOL by the use of commands
like mphinterp() or taking an export resulted in certain discrepancies between the results computed in COMSOL and that read by MATLAB.
Thus, the volume integration of the temperature gradient is performed in COMSOL itself and the results of the integration for each time
are sent to files. Matlab read these values and time averages them to get the result as in the paper (Sec. 2 of Liu and Thorne).
The errors expected are
> Fourier analysis is not done at all. This would have involved exporting data which, as mentioned before is giving errors
> The numerical errors by COMSOL are therefore not filtered off.
> The plot differs from the analytic solution for larger frequencies over 3000 Hz.
> It is to be noted from the paper by Liu and Thorne that the TE noise for the finite and infinite case are not very different. In
fact the correction factor goes as O(1). Thus, differences between finite and inifinte cases are unlikely to be prominent
in the log scale plots
The codes are put as a zip file. Corrections made to the codes will be uploaded as a reply.

Here is another plot with a mesh size slightly finer than the default Extra fine mesh in COMSOL.
One may notice that the value for the final frequency i.e. 10000Hz is different from the previous plot.
It maybe that the error for the higher frequencies is a result of the FEA. However, it may also be that
the appropriate boundary conditions required for an infinite model break down at high frequencies. 
Attachment 1: Jul_23_bettermesh2.eps


66

Tue Jul 23 20:53:37 2013 
Deep Chatterjee  Optics  General  Comparison between Liu and Thorne Results and COMSOL results for TE noise 
Quote: 
In this post I report of the results of TE noise simulated by COMSOL for the TE noise of Infinite test masses.
The aim was to follow the procedure by Liu and Thorne in their analytic calculations so that the same model could be used for the other
geometries.
The simulation is done in a different way than the TR simulations. It was observed that the output given by COMSOL by the use of commands
like mphinterp() or taking an export resulted in certain discrepancies between the results computed in COMSOL and that read by MATLAB.
Thus, the volume integration of the temperature gradient is performed in COMSOL itself and the results of the integration for each time
are sent to files. Matlab read these values and time averages them to get the result as in the paper (Sec. 2 of Liu and Thorne).
The errors expected are
> Fourier analysis is not done at all. This would have involved exporting data which, as mentioned before is giving errors
> The numerical errors by COMSOL are therefore not filtered off.
> The plot differs from the analytic solution for larger frequencies over 3000 Hz.
> It is to be noted from the paper by Liu and Thorne that the TE noise for the finite and infinite case are not very different. In
fact the correction factor goes as O(1). Thus, differences between finite and inifinte cases are unlikely to be prominent
in the log scale plots
The codes are put as a zip file. Corrections made to the codes will be uploaded as a reply.

Here is another plot with a mesh size slightly finer than the default Extra fine mesh in COMSOL.
One may notice that the value for the final frequency i.e. 10000Hz is different from the previous plot.
It maybe that the error for the higher frequencies is a result of the FEA. However, it may also be that
the appropriate boundary conditions required for an infinite model break down at high frequencies. 
Attachment 1: Jul_23_bettermesh2.eps


65

Tue Jul 23 20:53:37 2013 
Deep Chatterjee  Optics  General  Comparison between Liu and Thorne Results and COMSOL results for TE noise 
Quote: 
In this post I report of the results of TE noise simulated by COMSOL for the TE noise of Infinite test masses.
The aim was to follow the procedure by Liu and Thorne in their analytic calculations so that the same model could be used for the other
geometries.
The simulation is done in a different way than the TR simulations. It was observed that the output given by COMSOL by the use of commands
like mphinterp() or taking an export resulted in certain discrepancies between the results computed in COMSOL and that read by MATLAB.
Thus, the volume integration of the temperature gradient is performed in COMSOL itself and the results of the integration for each time
are sent to files. Matlab read these values and time averages them to get the result as in the paper (Sec. 2 of Liu and Thorne).
The errors expected are
> Fourier analysis is not done at all. This would have involved exporting data which, as mentioned before is giving errors
> The numerical errors by COMSOL are therefore not filtered off.
> The plot differs from the analytic solution for larger frequencies over 3000 Hz.
> It is to be noted from the paper by Liu and Thorne that the TE noise for the finite and infinite case are not very different. In
fact the correction factor goes as O(1). Thus, differences between finite and inifinte cases are unlikely to be prominent
in the log scale plots
The codes are put as a zip file. Corrections made to the codes will be uploaded as a reply.

Here is another plot with a mesh size slightly finer than the default Extra fine mesh in COMSOL.
One may notice that the value for the final frequency i.e. 10000Hz is different from the previous plot.
It maybe that the error for the higher frequencies is a result of the FEA. However, it may also be that
the appropriate boundary conditions required for an infinite model break down at high frequencies. 
Attachment 1: Jul_23_bettermesh2.eps


64

Tue Jul 23 20:53:37 2013 
Deep Chatterjee  Optics  General  Comparison between Liu and Thorne Results and COMSOL results for TE noise 
Quote: 
In this post I report of the results of TE noise simulated by COMSOL for the TE noise of Infinite test masses.
The aim was to follow the procedure by Liu and Thorne in their analytic calculations so that the same model could be used for the other
geometries.
The simulation is done in a different way than the TR simulations. It was observed that the output given by COMSOL by the use of commands
like mphinterp() or taking an export resulted in certain discrepancies between the results computed in COMSOL and that read by MATLAB.
Thus, the volume integration of the temperature gradient is performed in COMSOL itself and the results of the integration for each time
are sent to files. Matlab read these values and time averages them to get the result as in the paper (Sec. 2 of Liu and Thorne).
The errors expected are
> Fourier analysis is not done at all. This would have involved exporting data which, as mentioned before is giving errors
> The numerical errors by COMSOL are therefore not filtered off.
> The plot differs from the analytic solution for larger frequencies over 3000 Hz.
> It is to be noted from the paper by Liu and Thorne that the TE noise for the finite and infinite case are not very different. In
fact the correction factor goes as O(1). Thus, differences between finite and inifinte cases are unlikely to be prominent
in the log scale plots
The codes are put as a zip file. Corrections made to the codes will be uploaded as a reply.

Here is another plot with a mesh size slightly finer than the default Extra fine mesh in COMSOL.
One may notice that the value for the final frequency i.e. 10000Hz is different from the previous plot.
It maybe that the error for the higher frequencies is a result of the FEA. However, it may also be that
the appropriate boundary conditions required for an infinite model break down at high frequencies. 
Attachment 1: Jul_23_bettermesh2.eps


63

Tue Jul 23 20:53:37 2013 
Deep Chatterjee  Optics  General  Comparison between Liu and Thorne Results and COMSOL results for TE noise 
Quote: 
In this post I report of the results of TE noise simulated by COMSOL for the TE noise of Infinite test masses.
The aim was to follow the procedure by Liu and Thorne in their analytic calculations so that the same model could be used for the other
geometries.
The simulation is done in a different way than the TR simulations. It was observed that the output given by COMSOL by the use of commands
like mphinterp() or taking an export resulted in certain discrepancies between the results computed in COMSOL and that read by MATLAB.
Thus, the volume integration of the temperature gradient is performed in COMSOL itself and the results of the integration for each time
are sent to files. Matlab read these values and time averages them to get the result as in the paper (Sec. 2 of Liu and Thorne).
The errors expected are
> Fourier analysis is not done at all. This would have involved exporting data which, as mentioned before is giving errors
> The numerical errors by COMSOL are therefore not filtered off.
> The plot differs from the analytic solution for larger frequencies over 3000 Hz.
> It is to be noted from the paper by Liu and Thorne that the TE noise for the finite and infinite case are not very different. In
fact the correction factor goes as O(1). Thus, differences between finite and inifinte cases are unlikely to be prominent
in the log scale plots
The codes are put as a zip file. Corrections made to the codes will be uploaded as a reply.

Here is another plot with a mesh size slightly finer than the default Extra fine mesh in COMSOL.
One may notice that the value for the final frequency i.e. 10000Hz is different from the previous plot.
It maybe that the error for the higher frequencies is a result of the FEA. However, it may also be that
the appropriate boundary conditions required for an infinite model break down at high frequencies. 
Attachment 1: Jul_23_bettermesh2.eps


62

Tue Jul 23 20:53:37 2013 
Deep Chatterjee  Optics  General  Comparison between Liu and Thorne Results and COMSOL results for TE noise 
Quote: 
In this post I report of the results of TE noise simulated by COMSOL for the TE noise of Infinite test masses.
The aim was to follow the procedure by Liu and Thorne in their analytic calculations so that the same model could be used for the other
geometries.
The simulation is done in a different way than the TR simulations. It was observed that the output given by COMSOL by the use of commands
like mphinterp() or taking an export resulted in certain discrepancies between the results computed in COMSOL and that read by MATLAB.
Thus, the volume integration of the temperature gradient is performed in COMSOL itself and the results of the integration for each time
are sent to files. Matlab read these values and time averages them to get the result as in the paper (Sec. 2 of Liu and Thorne).
The errors expected are
> Fourier analysis is not done at all. This would have involved exporting data which, as mentioned before is giving errors
> The numerical errors by COMSOL are therefore not filtered off.
> The plot differs from the analytic solution for larger frequencies over 3000 Hz.
> It is to be noted from the paper by Liu and Thorne that the TE noise for the finite and infinite case are not very different. In
fact the correction factor goes as O(1). Thus, differences between finite and inifinte cases are unlikely to be prominent
in the log scale plots
The codes are put as a zip file. Corrections made to the codes will be uploaded as a reply.

Here is another plot with a mesh size slightly finer than the default Extra fine mesh in COMSOL.
One may notice that the value for the final frequency i.e. 10000Hz is different from the previous plot.
It maybe that the error for the higher frequencies is a result of the FEA. However, it may also be that
the appropriate boundary conditions required for an infinite model break down at high frequencies. 
Attachment 1: Jul_23_bettermesh2.eps


68

Tue Jul 23 20:53:45 2013 
Deep Chatterjee  Optics  General  Comparison between Liu and Thorne Results and COMSOL results for TE noise 
Quote: 
In this post I report of the results of TE noise simulated by COMSOL for the TE noise of Infinite test masses.
The aim was to follow the procedure by Liu and Thorne in their analytic calculations so that the same model could be used for the other
geometries.
The simulation is done in a different way than the TR simulations. It was observed that the output given by COMSOL by the use of commands
like mphinterp() or taking an export resulted in certain discrepancies between the results computed in COMSOL and that read by MATLAB.
Thus, the volume integration of the temperature gradient is performed in COMSOL itself and the results of the integration for each time
are sent to files. Matlab read these values and time averages them to get the result as in the paper (Sec. 2 of Liu and Thorne).
The errors expected are
> Fourier analysis is not done at all. This would have involved exporting data which, as mentioned before is giving errors
> The numerical errors by COMSOL are therefore not filtered off.
> The plot differs from the analytic solution for larger frequencies over 3000 Hz.
> It is to be noted from the paper by Liu and Thorne that the TE noise for the finite and infinite case are not very different. In
fact the correction factor goes as O(1). Thus, differences between finite and inifinte cases are unlikely to be prominent
in the log scale plots
The codes are put as a zip file. Corrections made to the codes will be uploaded as a reply.

Here is another plot with a mesh size slightly finer than the default Extra fine mesh in COMSOL.
One may notice that the value for the final frequency i.e. 10000Hz is different from the previous plot.
It maybe that the error for the higher frequencies is a result of the FEA. However, it may also be that
the appropriate boundary conditions required for an infinite model break down at high frequencies. 
Attachment 1: Jul_23_bettermesh2.eps


69

Wed Jul 24 21:08:24 2013 
Deep Chatterjee  Optics  General  TR results for different dimensions  In this post I simulate the procedure of calculating the TR noise for finite cavities as proposed by Heinert and check for a
match.
The technique of performing all necessary calculations in COMSOL and exporting the results was applied to the TR codes.
It was seen that the codes gives similar output as the technique of extraction of Fourier coefficients in place of time averaging
as has been done in the codes of Koji Arai. One can see the output as the present code runs to be similar to the previous ones
found in the SVN.
However, the results in the present case were off by a constant factor close to 100. This maybe due to some 'm'  'cm' or similar difference between
analytic calculations and COMSOL values of parameters. Although, it has not been found yet, the correction is hopeful to be
found soon.
The codes give results similar to the analytic result for other values of the mirror radius and beam radii (apart from the constant
factor I have mentioned above). One may have a look at the trend of the graphs between analytic and simulated values in the plots
attached. These plots are for the case when the mirror radius = 25m while the beam radius = 9 cm i.e. the original radii were 0.25m
and 9cm respectively i.e. the ratio has been changed by a order of 2.
As mentioned before the reason for the constant factor difference will be looked into. 
Attachment 1: Jul24.pdf


Attachment 2: Jul24_acalc.pdf


71

Thu Jul 25 13:21:46 2013 
Deep Chatterjee  Optics  General  TR results for different dimensions 
Quote: 
In this post I simulate the procedure of calculating the TR noise for finite cavities as proposed by Heinert and check for a
match.
The technique of performing all necessary calculations in COMSOL and exporting the results was applied to the TR codes.
It was seen that the codes gives similar output as the technique of extraction of Fourier coefficients in place of time averaging
as has been done in the codes of Koji Arai. One can see the output as the present code runs to be similar to the previous ones
found in the SVN.
However, the results in the present case were off by a constant factor close to 100. This maybe due to some 'm'  'cm' or similar difference between
analytic calculations and COMSOL values of parameters. Although, it has not been found yet, the correction is hopeful to be
found soon.
The codes give results similar to the analytic result for other values of the mirror radius and beam radii (apart from the constant
factor I have mentioned above). One may have a look at the trend of the graphs between analytic and simulated values in the plots
attached. These plots are for the case when the mirror radius = 25m while the beam radius = 9 cm i.e. the original radii were 0.25m
and 9cm respectively i.e. the ratio has been changed by a order of 2.
As mentioned before the reason for the constant factor difference will be looked into.

The discrepancy related to the difference between the analytic and COMSOL results has been partially addressed. Attached is another
plot showing the comparison. The ratio this time between the COMSOL results and the analytic results is between 0.7  0.8. This difference
will be looked into. It is, however, observed that the difference is not a constant factor  it has to do with the model file. 
Attachment 1: Jul_25.pdf


