LIGO: The Dawn of Gravitational Wave Astronomy
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Part Number | 61 | |
| Number of Parts | 169 | |
| Author | ||
| License | CC Attribution - NonCommercial - ShareAlike 3.0 Unported: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal and non-commercial purpose as long as the work is attributed to the author in the manner specified by the author or licensor and the work or content is shared also in adapted form only under the conditions of this | |
| Identifiers | 10.5446/21158 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
EuroPython 201661 / 169
1
5
6
7
10
11
12
13
18
20
24
26
29
30
31
32
33
36
39
41
44
48
51
52
53
59
60
62
68
69
71
79
82
83
84
85
90
91
98
99
101
102
106
110
113
114
115
118
122
123
124
125
132
133
135
136
137
140
143
144
145
147
148
149
151
153
154
155
156
158
162
163
166
167
169
00:00
Wind waveGravitationGravitational waveMedical imagingFingerprintVideo gameProjective planeLecture/ConferenceMeeting/Interview
00:54
Level (video gaming)Gravitational waveCollaborationismLie groupAstrophysicsMassProjective planeCollaborationismPhysicalismGravitational waveFrequencyGeneral relativityTheoryLecture/ConferenceComputer animation
01:51
SpacetimeGeneral relativityCausalityGravitationMassCurvatureCurveTrajectoryNichtlineares GleichungssystemTensorFood energyContent (media)Mathematical objectDivisorLecture/ConferenceComputer animation
02:40
Pointer (computer programming)PredictabilityWind waveGravitationCausalityBitGeneral relativityGravitational waveCartesian coordinate systemDirection (geometry)SpacetimeDimensional analysisComputer animationLecture/Conference
03:26
MassCross section (physics)SpacetimeSound effectDistanceGravitational waveLaserComputer animationLecture/Conference
04:11
Wind waveFlow separationMedical imagingLaserCategory of beingFunction (mathematics)Phase transitionComputer animationDiagramLecture/Conference
05:01
LaserError messageSoftware developerOpticsPoint (geometry)Multiplication signArmSound effectDiagramProgram flowchartLecture/Conference
05:47
Gravitational wavePhysicistEvent horizonArmLengthLecture/Conference
06:35
BuildingZoom lensVacuumPhysical systemScaling (geometry)Greatest elementLecture/Conference
07:18
Physical systemGravitational waveMassTable (information)Core dumpLaserFunction (mathematics)Analytic continuationPower (physics)Direction (geometry)Lecture/ConferenceMeeting/Interview
08:06
Function (mathematics)Execution unitParameter (computer programming)Order (biology)OpticsSoftware testingLecture/ConferenceComputer animation
08:51
Maxima and minimaMassSoftware testingArmBitLeakDifferent (Kate Ryan album)FeedbackRight angleVideo gameSpacetimeLecture/ConferenceComputer animation
09:42
Displacement Mapping3 (number)NoiseQuantumFrequencyMeasurementSpectrum (functional analysis)Population densityHill differential equationPressureFrequencyRange (statistics)Band matrixSpacetimeQuicksortLIGOLecture/ConferenceEngineering drawingDiagram
10:35
Spectrum (functional analysis)Population densityMeasurementNoiseQuantumFrequencyPlotterSpectrum (functional analysis)MeasurementPower (physics)Population densityCurveFrequencyRevision controlProjective planeConnectivity (graph theory)BitLecture/ConferenceEngineering drawingDiagram
11:24
MeasurementNoiseQuantum3 (number)Spectrum (functional analysis)Population densityFrequencyDisplacement MappingPressureDifferent (Kate Ryan album)Limit (category theory)Sensitivity analysisNoise (electronics)QuicksortSource codePhysicalismLecture/ConferenceEngineering drawingDiagram
12:09
MeasurementNoiseQuantumPressureFrequencyDisplacement MappingNoise (electronics)BitSuspension (chemistry)Table (information)Physical systemDrop (liquid)FrequencyKinetische GastheorieSoftware testingMassVibrationArmLecture/ConferenceDiagram
12:56
Displacement MappingMeasurementNoiseQuantumPressureFrequencyMassSoftware testingCurveQuantumNoise (electronics)Object (grammar)Quantum mechanicsAnalytic continuationStreaming mediaDiscrete groupFood energySound effectLecture/ConferenceDiagram
13:39
MeasurementNoiseQuantumFrequencySpecial unitary groupSummierbarkeitMetreDisplacement MappingSensitivity analysisGreatest elementTerm (mathematics)CurveMultiplication signNumber2 (number)Noise (electronics)MeasurementDiagramLecture/ConferenceComputer animation
14:38
MeasurementNoiseQuantumFrequencyFunction (mathematics)Category of beingLine (geometry)Software testingMassMultiplication signLecture/ConferenceEngineering drawingDiagram
15:30
MeasurementNoiseQuantumFrequencySpectrum (functional analysis)Population densitySpecial unitary groupMassSoftware testingFiber (mathematics)VibrationString (computer science)Asynchronous Transfer ModeHarmonic analysisGravitational waveNoise (electronics)QuicksortEngineering drawingDiagramLecture/Conference
16:28
Maxima and minimaSpacetimeCollaborationismComputer simulationSimulationExtreme programmingField (computer science)Multiplication signLecture/Conference
17:16
Sound effectGravitational waveUniverse (mathematics)OrbitWind wavePhysical systemRepresentation (politics)Right angleFrequencyOrder (biology)CollaborationismLecture/Conference
18:13
FrequencyState observerCuboidRight angleLecture/ConferenceComputer animation
19:02
FrequencyGravitational waveFrequencyRevision controlLecture/ConferenceDiagram
19:47
FrequencyInterior (topology)Wind wavePlotterWaveformRow (database)MereologyComputer fileComputer simulationAlgorithmGeneral relativityLecture/ConferenceComputer animationMeeting/Interview
20:33
FrequencyArc (geometry)Noise (electronics)Form (programming)MassRow (database)Matching (graph theory)PredictabilityFunctional (mathematics)Multiplication signFrequencyLecture/ConferenceComputer animation
21:18
FrequencyTerm (mathematics)CollisionFrequencyGravitational waveDifferent (Kate Ryan album)CuboidEmailEvent horizonComputer animationLecture/Conference
22:15
Event horizonCycle (graph theory)Proof theoryCurveCausalityMultiplication signLecture/ConferenceDiagram
23:14
QuicksortGravitational waveStochastic processRight angleMultiplication signAlgorithmNoise (electronics)CuboidEvent horizonSigma-algebraLecture/ConferenceDiagramComputer animation
24:07
Sigma-algebraQuicksortMultiplication signShift operatorLine (geometry)CuboidEvent horizonGravitational waveNumberRandomizationLecture/ConferenceComputer animationDiagram
25:16
3 (number)10 (number)Limit (category theory)CollisionGeneral relativityPhysical systemNumberComputer simulationEstimatorDistanceState observerBookmark (World Wide Web)Symbol tableUniverse (mathematics)CircleMassSpecial unitary groupLecture/Conference
26:01
Multiplication signMassSpecial unitary groupMathematicsEntire functionFood energyGravitational waveSpacetimeMeasurementMetropolitan area networkLecture/Conference
26:47
10 (number)Collision3 (number)Multiplication sign2 (number)Special unitary groupOrder of magnitudeEvent horizonFood energyUniverse (mathematics)WordLecture/Conference
27:39
Binary fileEvent horizonSensitivity analysisSign (mathematics)Computer networkPlanningMultiplication signDistanceVolume (thermodynamics)CubeVector potentialEvent horizonSensitivity analysisMultiplicationCurveLecture/Conference
28:31
Event horizonComputer networkBinary fileSensitivity analysisSign (mathematics)PlanningBinary codeMathematicsObject (grammar)General relativityData structureWater vaporCollaborationismArmSoftwareSpacetimeQuicksortBitPlanningGravitational waveLecture/Conference
29:33
Data analysisAlgorithmLibrary (computing)PlotterMathematical analysisWind waveBinary codeCompact spaceData analysisArithmetic meanProcess (computing)Type theoryEvent horizonTape driveLecture/Conference
30:22
PlotterData analysisMathematical analysisIntelAlgorithmLibrary (computing)Binary fileComputer networkSurjective functionEvent horizonReal-time operating systemConstructor (object-oriented programming)Tape driveWaveformAlgorithmPlotterInformation retrievalSignal processingLibrary (computing)Template (C++)MereologyLecture/Conference
31:09
Mathematical analysisSimulationMachine learningPlotterOpen setPlotterRight angleComputer simulationCollaborationismInterface (computing)LaptopOpticsMachine learningBitSimulationUniverse (mathematics)CurveLecture/Conference
31:55
Open setControl flowWindowMathematical analysisPhysical systemPhysicsLaptopWind waveComputer filePlotterGame controllerCoordinate systemPhysical systemAutomationLecture/Conference
32:58
Mathematical analysisControl flowPhysical systemGravitational wave2 (number)Mathematical analysisDescriptive statisticsControl systemAutomationFinite-state machineAutomatonHierarchyAtomic numberData miningLecture/Conference
33:46
Control flowDigitizingAnalogyInterface (computing)Data conversionDigital signalReal-time operating systemControl systemDot productSignal processingAutomatonAutomationLecture/ConferenceDiagram
34:32
Control flowState of matterSocial classVirtualizationPhysical systemMereologyMultiplication signFinite-state machineDot productState of matterGraph (mathematics)Social classGodLogicLecture/Conference
35:34
3 (number)State of matterSocial classMetropolitan area networkSineState of matterDampingElectronic mailing listGame theoryFilter <Stochastik>TupleConnected spaceOvalArrow of timeGraph (mathematics)Right angleLecture/Conference
36:18
Graph (mathematics)Line (geometry)State of matterGraph (mathematics)Module (mathematics)Mechanism designProcess (computing)Standard deviationGodMathematical analysisSoftwareLecture/Conference
37:01
VarianceDemonGraph (mathematics)Physical systemLogicState of matterCodeException handlingControl flowClient (computing)CASE <Informatik>AutomatonMaxima and minimaGraph (mathematics)Representation (politics)SoftwareAutomatonState of matterDampingLecture/Conference
37:49
CASE <Informatik>DemonPhysical systemGraph (mathematics)State of matterLogicCodeException handlingControl flowClient (computing)WeightRoyal NavyMaxima and minimaProcess (computing)Electronic mailing listComputer architectureLibrary (computing)Arithmetic meanComputer clusterInterface (computing)MehrprozessorsystemProcess (computing)CodeDemonGame controllerShared memoryNeuroinformatikThread (computing)Source codeLecture/Conference
38:49
CASE <Informatik>DemonClient (computing)Maxima and minimaGraph (mathematics)Server (computing)Physical systemLogicState of matterCodeException handlingControl flow3 (number)Information managementShared memoryProcess (computing)CodeException handlingSemiconductor memoryDemonTraffic reportingError messageGame controllerMereologyCurveGraph (mathematics)Lecture/Conference
39:34
Game controllerRevision controlAttribute grammarPhysicalismSoftwareState of matterInterface (computing)Social classMessage passingClient (computing)Server (computing)WeightLecture/Conference
40:38
Euler anglesGravitational waveGravitationFormal languageField (computer science)Gravitational waveMathematical analysisGame controllerField (computer science)View (database)PhysicalismLecture/Conference
41:33
Event horizonHoaxMathematical analysisThumbnailReal numberFigurate numberMultiplication signCollaborationismGravitational waveLecture/Conference
42:45
QuicksortUtility softwareObservational studyEvent horizonLecture/Conference
43:47
Point (geometry)Event horizonRight angleMassInformationGravitational waveBinary codeReading (process)Universe (mathematics)Musical ensembleLecture/Conference
44:54
System administratorMultiplication signEndliche ModelltheorieMeasurementEvent horizonLecture/Conference
45:38
Endliche ModelltheorieRow (database)Event horizonUniverse (mathematics)Category of beingError messageGravitational waveLecture/Conference
46:21
Multiplication signUniverse (mathematics)Special unitary groupDistanceMaxima and minimaFraction (mathematics)Gravitational waveDisk read-and-write headEvent horizonPoint (geometry)Lecture/Conference
47:14
ReliefVideo gameState observerEndliche ModelltheoriePhysicalismMassElectronic mailing listCurvatureCategory of beingParameter (computer programming)Inclined planeQuicksortPredictabilityUniverse (mathematics)General relativityObject (grammar)Reverse engineeringMathematicsLecture/Conference
48:56
Domain nameUniverse (mathematics)Endliche ModelltheorieEvoluteDistribution (mathematics)Multiplication signCuboidSimilarity (geometry)MassMathematical analysisSpecial unitary groupBayes-EntscheidungstheorieEvent horizonDistanceLecture/Conference
50:01
Open sourceSoftwareGenderEuler anglesFunction (mathematics)System callMultiplication signAlgorithmComputing platformCollaborationismRight angleRevision controlNatural numberBitOpen setLecture/Conference
52:09
Order (biology)Point (geometry)Online helpMathematical analysisGame controllerInformationParallel portProcess (computing)Computing platformNeuroinformatikComputer clusterGravitational waveThermal expansionSupercomputerSignal processingShared memorySemiconductor memoryCluster analysisComputer simulationScheduling (computing)Physical systemBitArithmetic meanEvent horizonRight angleLecture/Conference
54:39
Event horizonEndliche ModelltheorieINTEGRALSoftware testingBitVisualization (computer graphics)Multiplication sign2 (number)PlotterLecture/Conference
55:26
VelocityCodeMassSpacetimeLecture/ConferenceComputer animationDiagramMeeting/Interview
Transcript: English(auto-generated)
00:00
I'm really happy to introduce James Rowlands. He has been, we've just been talking, and I think it's so amazing. He's been working in the gravitational waves community for 18 years, like all his professional life. And he's going to tell you more about his research
00:20
and the project and discoveries and how Python was involved. So please very welcome James Rowlands. Hello, can everybody hear me? How's it going? Ooh, very good.
00:41
All right, so yes, I'm Jameson Rowlands. I work for the LIGO project, which is a project to detect gravitational waves. Brief overview, it consists of these two big interferometers, which I'll describe in a minute. It's an NSF project in the United States.
01:04
Although we have many international collaborators, 60 institutions, 1,000 individuals around the world. The two observatories are separated. One is in Washington State, and the other is Louisiana. 3,000 kilometers, 10 milliseconds.
01:24
All right, so a little background about what are gravitational waves. So Einstein's general theory of relativity, which is one of the most successful physics theories in history, basically, it's been 100 years.
01:41
This year is the anniversary, 100 year anniversary. And it's been basically unaltered since he gave birth to it. It's really incredible. And basically the idea is that the curvature, that gravity is curvature of space time. So masses in space cause the space time to curve.
02:04
And then the curved space time causes masses to change their trajectory. And this is the only equation in the talk, I promise. And this is the Einstein's equation. It's the curvature is described by this mathematical object called a tensor over here.
02:23
And then the mass energy content, like what is in space is on the other side. And it's related by this very, very small factor, which indicates that space is very, very stiff. It's very hard to bend.
02:41
So one of the interesting predictions of general relativity is that it predicts there should be waves of gravity. And I like this animation cause it looks kind of a little bit sexy. But so you can imagine that what's happening here is that through the central axis of this tube
03:00
is the movement of a gravitational wave. A wave is propagating through this tube or in this direction. And what you can see, what the tube is doing is showing how the surrounding space time is gonna move. So perpendicular to the direction of travel, the space is compressing in one dimension
03:20
and expanding in the other. And then as the wave moves, it does the opposite. So it kind of does that squeezing and stretching motion. So if you look at the cross section of the tube and you put some masses at the edges, you'll see that the masses, because the space is bending
03:40
are gonna move with the space, all right? So how can we use this effect to look for the gravitational waves? So what we do is we make this device called an interferometer. We can use light to measure these distances in space.
04:00
So you imagine these two, we have here is a laser, a beam splitter, and then two mirrors. And if we shoot the laser beam at the beam splitter, it splits the light. The light goes to the two mirrors and bounces off, then comes back to the beam splitter where it is recombined.
04:23
And what happens is you take this very interesting property of light, which is that it can interfere with itself, and what you can do is very precisely measure the relative separation of these two end mirrors. So this is the, you can see the waves
04:40
going in the two arms. They're out of phase at the output port, but then when the end mirrors move, they become in phase, and so you get the light goes up and down at the output port. It's really, it's a very simple, elegant concept. And so how do we use this?
05:01
So we take this very simple concept of laser beam mirrors and after many, many years of development, we made it much more complicated because, as I'll explain shortly, it's this very complicated optical system now, and the point of all of these extra optics,
05:23
these extra folding of the light, is to try to amplify the signal. So one thing I'll just point out is that instead of just having the light go down to the end and bounce off the mirror and come back, we actually have cavities in the arms which allow the light to build up. It bounces in the arms many, many times,
05:42
and that amplifies the effect of the end mirrors moving. And so then eventually, after many decades of research, this idea, by the way, to detect gravitational waves with these Michelson interferometers came in the 60s. And so the physicists who kind of came up with this idea
06:04
started to make very small experiments that were only a meter. Well, initially they tried to detect them with bars, but I won't go into the whole history. But then they started to make small interferometers and then they kept getting bigger and bigger and bigger until we got to LIGO where the length of these arms
06:20
is four kilometers long. So this from here all the way to the end here is four kilometers. We have two detectors, like I said. One is in the desert in Washington and the other is in the swamp in Louisiana. So this is what it looks like inside. So this here is inside this central building.
06:44
Okay, if we kind of zoom on to the inside there. It's a big vacuum system. So the whole interferometer is enclosed in this big vacuum. These big chambers here hold the mirrors. Here's a person for scale.
07:00
So it's very big inside here. So this is one of the mirrors. So you can see at the bottom here, that's the mirror. The red thing is the mirror. It's about this big. It weighs 40 kilograms. It's suspended. So it's not firmly attached to the ground
07:20
because of course the ground moves a lot and we don't want the motion of the ground to confuse the instrument and make it think it's a gravitational wave. So we isolate the mirrors from the ground with these very complicated seismic isolation systems. There's actually this mirror is hung from this mass which is hung from another mass here
07:40
which is hung from another mass here which is hung from this table which has active seismic isolation system. And so this is one of the core mirrors. This is our laser which can output over 100 watts of continuous light power. That doesn't sound like much because you think of a light bulb in your house as 100 watts,
08:01
but the light bulb is outputting light in all directions. And this laser beam is focused into a very tiny spot and if you were to get hit by it it would not be fun for you. Here's what it looks like at the output of the interferometer.
08:20
So actually where we make the detection is in this assembly here where that what we call the photo detector that measures the light is inside here. And so the light goes through the whole interferometer and comes to this chamber where it bounces around on some more optics and eventually is caught in this assembly here.
08:43
And here's another picture. I think this is another very sexy picture. So this is inside the end chamber where the end test mass is. And so you can see this is the test mass here. This is what we call the end mirror.
09:00
And so behind this guy here down here is the four kilometer long arm. And then this whole assembly here is to take a little bit of the light that leaks through the mirror and then it bounces up in here and goes up onto another optical table up here where we measure the light. So we actually measure the light
09:22
in many different places throughout the interferometer. So we're constantly getting feedback about what's going on inside the instrument. All right, so basically light is, I mean LIGO is just a transducer of the space time strain
09:40
of the movement of space time to an electrical signal. That's basically what it is. It's really very similar to a microphone in a lot of ways. I mean, you know, a microphone when it gets the pressure from the air, it causes the microphone to move and we turns that into an electrical signal that we can then digitize and process and listen to.
10:01
Well, it's very similar with LIGO. And interestingly, the frequency range that LIGO can detect of the motion of space time is the audio frequency range. It's exactly the same bandwidth that you hear with your ears.
10:20
It's from about a little less than, from like 40 hertz up to a couple kilohertz. And so this is sort of our primary thing that we measure. We look at this, scientists and LIGO look at these plots a lot. So this is called the strain spectrum of LIGO.
10:42
The spectral amplitude, spectral density. And it's basically just a measure of how much power there is at each frequency in the detector. So you can see here the gray curve. This is what the strain spectrum looked like in the initial versions of LIGO at the end of the initial LIGO project,
11:03
which ended in 2009. And then in 2009, we ripped the whole instrument apart and we completely put it back together with all new components to try to make this curve go down. And then that's what we got to with this black curve, basically. This is only for one instrument.
11:21
The two instruments are slightly different, obviously. So the spectrum is a little bit different, but it's mostly the same. And so this is where we are in our first observing run, which happened in 2015 with the advanced detectors. And let me just talk really briefly about what limits this.
11:42
And so what we're trying to do is we're trying to make this measurement as sensitive as we possibly can. And so what we wanna be limited by is actually, is physics. We don't wanna be limited by any sort of technical noise sources like, is our amplifier noisy? That would be a failure, basically.
12:01
We would think of it as a failure if our amplifier was too noisy. And so what do we have here? So at the left side in this sort of scion trace is the seismic noise. I mean, we can try to do, we can try to suppress the seismic noise as much as we can. And that's what we do with these suspensions,
12:22
with the seismic isolation tables. And so what happens is the ground is moving quite a bit. And so all of those seismic isolation, the isolation systems attenuate that motion. That's why you have this very steep drop off in frequency here.
12:40
At this green trace down here is interesting because that's actually thermal motion in the test mass. So the actual test mass, because it's not at absolute zero temperature is going to be vibrating. All of the molecules in the test mass will be vibrating.
13:01
And that is motion that will limit how much we can detect. And then the red curve is quantum mechanical noise on the light itself. So the light is not just a continuous wave. It's actually a bunch of individual photons. That's a quantum mechanical,
13:21
light is a quantum mechanical object. And so those photons, the fact that they're discrete little packets of energy has an effect on the noise. So we can't detect, we don't detect a continuous stream. It's like rain. And that rain causes a noise. So where do we get at ultimately?
13:41
So down at the bottom of this, this is our strain here. And over on the other side is what we call the displacement sensitivity in terms of meters. So at the bottom of this curve, we have three times 10 to the minus 20 meters.
14:00
I'm letting everybody think about that number for a second. Three times 10 to the minus 20 meters. That's an incredibly small number. And I've been working on LIGO for 18 years, and that number still blows my mind. So what does it mean? So here's an atom. This is an atom. It's 10 to the minus 10 meters.
14:20
An atom, a hydrogen atom is 10 to the minus 10 meters. We go in, this is a proton. We like zoomed up to the edge of a proton. That's 10 to the minus 18 meters. That's still bigger than that noise we're measuring. How is that possible?
14:46
It's crazy. It's nuts. I don't know how we do it. I know how we do it. So what does it sound like? So let's put it all together.
15:02
This is literally just the output of the detector plugged into a speaker. I'm not kidding. We listen to this in the control room. This is the data that we take just plugged into a speaker. It's like so stupid simple.
15:22
So all of the, you hear the high pitched things? Those are all of these very narrow lines. Those lines are because the test masses are hung by these very small fibers that are actually made of glass. Cause the test mass, they're made of the same material that the test mass is.
15:41
And so those vibrate like a violin string. And so we call them violin modes. And so they have those, you know, all of those high pitched harmonics. And then what we can do is we can filter this. So we try to filter out the low frequency. Well, we filter out all of these lines.
16:05
And then that's what we're left with. So that's filtering out all of the things that we know are not gravitational waves. And we get this low sort of rumbling noise.
16:24
All right, so that's what we detect. Meanwhile, 1.3 billion years ago, this happened. So this is a very cool simulation from this collaboration called S-X-S,
16:41
which is simulations of extreme space times. And this is two black holes that are orbiting around each other. And what's behind is just a static picture of the Milky Way galaxy. Just a light, a star field in the background. And all this crazy stuff you're seeing is the space time that's being curved and warped
17:03
is bending the light. Bending the light that's coming from behind it. That's called gravitational lensing. And so this is just a way, because the black holes are black, they're obviously in space where there's no, there's nothing to see really, no light. So what they do is they put this picture behind it
17:22
so you can see. I mean, we actually observe things like this in the universe today. We observe these gravitational lensing effects. This is obviously special because of the fact that we're seeing these black holes. So they orbit around each other. As they orbit around each other, they emit gravitational waves.
17:42
So this is an animation, also from that same collaboration, of what the waves look like, or what the representation of the waves as they leave the system. So you've got the two black holes orbiting around each other. This red and yellow is the waves being emitted.
18:00
And as they get closer, the waves get higher amplitude, the frequency gets bigger, until right at the very end, you get this big burst of waves. And then you're just left with one black hole at the end. So then, on September 14th,
18:20
which is funny because on September 15th, we were gonna start having a science run. We're gonna start observing. But we were in a, what we call an engineering run, where we were getting ready to observe. We were very close. Basically, everything was completely ready, but we hadn't just, you know, checked the box.
18:43
And then this happened. So this is the real signal. And this is pitch shifted up, so you can hear the, you hear the little, the chirp.
19:01
And so this is actually what was measured by the instrument from black holes that look like that. So this was the first detection of gravitational waves. And you can see this is basically what the signal looked like in the Hanford detector, and this is what it looked like in the Livingston detector.
19:21
I'll be playing it one more time. The chirp at the end. So that, the higher pitched version is pitch shifted up, so you can sort of, you can hear the chirping more. But that's the, the chirp is the frequency getting higher
19:44
as the two black holes get closer together, and then you can hear the amplitude get louder as well. And so this is another, this is the plot from our paper that we published. This was the first plot. And so you can see up there at the very top is just the waveform that we measured.
20:03
I mean, it's literally just, you know, like a wave file. The next row is a numerical simulation. So we took the, we took what we measured, we tried to reconstruct what we think that the signal is,
20:20
based on what we know about, you know, numeric, what we know about general relativity. We have lots of complicated algorithms to try to predict what these, what the signal will look like. And we think that from what we measure, we say, okay, we think these are black holes of this mass, and they should, in pure form, without the noise of the detector, look like this.
20:43
And so that's what's on the second row. And then we take the top row and we subtract the second row and we get the third row. And you can see all that's left is just noise. So what does that show? It shows that there's actually a pretty good match. If you take away our prediction of the signal from what we actually measure,
21:01
you're left with basically nothing. And so we kind of use that as evidence. That's not how we, that's not how we prove it, but it's a nice, it's a nice, nice thing to see. And this is the frequency as a function of time. So you can see it's only, it's about 200 millisecond long signal, and the frequency starts very low.
21:21
It's something like 40, 50 Hertz, and then it goes up to like 300 Hertz. And we call this signal GW150914, first ever gravitational wave detection. So then, that was day minus one of our observing run,
21:41
and so we kept going. And then on Boxing Day, on December 26, which was actually December 25th in the United States, everybody started to get more email all of a sudden, and we detected another event. And this one is a little bit different. In the first event, the two black holes
22:02
are very similar size. In this event, they're different, the size difference is bigger. And so you have a smaller, one smaller that's one much smaller than the other. And so the event is much, is longer. It's over the course of a second, and we see many more cycles of the event.
22:25
So this is a little bit complicated, but I just wanna show it just because this is kind of what we show as evidence of the proof. These curves down here are what we call the background.
22:40
And we get these curves by shifting the data from the two instruments relative to each other so that there's no causality between them. So if you shift them by, remember I said that the light travel time between the two detectors was 10 milliseconds? Well, if I shift the data at a second,
23:00
so that one is shifted for one second relative to the other, there's no way that something that's traveling at the speed of light is gonna have a coincident signal in both of those things. So that's how we generate this background. We shift the data and then look for gravitational waves, and we don't, we see this very sort of expected
23:24
random signals. And then these are what we detected during the first observing run. So over here on the right is the first signal, which is just screamingly loud. It's like really loud. We never expected we would see signals that, really, we didn't really expect to see signals that loud,
23:41
so we made all these, spent all these time making these very sensitive algorithms to listen to tiny signals and noise, you know, like needle dropping, and then we get this really loud signal. You know, whatever. So it helps us because, of course, the next one was not so loud, and so that's the GW15-12-26, the Boxing Day event.
24:04
And of course, people might have heard about five sigma. That's what scientists use to try to say that something is significant. And so you can see, those are how the sigma move up as you get louder and louder. And so the purple is kind of what we consider,
24:22
actually, this black one here is the background because of the fact that the first signal is actually in the data. The first signal, even if you time shift it, it is coincident with, occasionally, with random events in the other detector.
24:40
And because it's so loud, it actually looks like fake signals. So we have to, we remove that. And then, also in October, we got another event that's kind of interesting. You know, if there were no gravitational wave signals, all of the orange boxes would just be on that line. And so anything that's off of that line,
25:01
that's a little bit interesting. And the further away it is, it's much more interesting. So we have this another event. You can see it's only like two sigma. So it's not very strong, but you know, I'll let you guys be the judge. So here's some numbers. So it's kind of incredible to me that with this tiny amount of data,
25:21
we can learn a lot about the system because we know general relativity very well. We can run these numerical simulations. We can sort of reconstruct what it looked like. So we can, we get an estimate of how far away it is. 1.3 billion light years, which is 1 10th of the distance
25:40
to the edge of the observable universe. So it's really far away. This is one of my favorites here. The big black hole was 36.2. That symbol there, M with the circle with the dot, is the mass of the sun. That's what we use frequently in astronomy to measure masses. It's called a solar mass.
26:01
So this black hole was 36 times the mass of the sun. The other one was 29 times the mass of the sun, which, and the final black hole, was 62 times the mass of the sun. Well, it doesn't take very fancy math to see that that doesn't add up, right? So what happened? There's three solar masses missing.
26:22
That was the gravitational waves. So these two black holes colliding turned three entire suns, they just like completely evaporated the energy and turned it into gravitational waves. That's pretty incredible. That's a lot of energy that went into bending the space. And then this one, this is just crazy here.
26:43
So the luminosity, the ergs is another measure of energy that we frequently use in astronomy. 3.6 times 10 to the 56 ergs per second. That's how much, at the very peak, how much energy per time it was emitting.
27:01
So the luminosity of the sun is 10 to the 33. So that's 23 orders of magnitude bigger than the brightness of the sun. And then the entire universe, the luminosity of the entire universe, if you don't have any crazy events like this,
27:22
just the ambient universe, is 10 to the 55 ergs. So at the peak of this event, it was brighter than the entire rest of the universe, which is, these events are very, very energetic.
27:40
All right, so that's the story of LIGO. We're currently, we took the instruments down again to try to improve them. Cause every time we improve, we go out in distance, but when we go out in distance, that's the volume is the cube.
28:00
So little increase in distance makes a lot of extra volume. So we get a lot more potential events. So that's why we keep trying to improve the sensitivity. Once we get up to our design sensitivity, remember we're at that black curve. We're not at where we ultimately wanna be yet. And I didn't explain why we're not there yet,
28:20
but you can come ask me after if you'd like. But if we get to that ultimate design sensitivity, we'll see multiple events a week, we hope. So more big discoveries soon. We hope to see binary neutron stars colliding. So black holes are just these mathematical
28:40
general relativity objects. But neutron stars have structure, and so if we see those smashing together, we can learn stuff, lots of interesting things. Those might produce electromagnetic waves that we could detect with telescopes, which is very interesting. And then we've got more detectors that will join our network soon.
29:00
Virgo is a French-Italian collaboration that will hopefully be taking data soon. Kagura's a Japanese collaboration. We're hoping to build another LIGO detector in India, and then of course, we're planning to make much bigger detectors with longer arms and space, all sorts of things like that.
29:21
So this is the Python conference. Wanted to say a little bit how we use Python, which is basically everywhere. I mean, we love Python in science in general, I think, but particularly in the gravitational wave community. It used to be all MATLAB for various reasons,
29:41
but Python is becoming much more popular now. So for data analysis, our flagship search, the search that looks for, so compact binary coalescence. So compact means very compact stars,
30:00
black holes, neutron stars. Binary is obviously two stars, and coalescing is that process where they spin together and merge. So searches for those types of events, we use a pipeline called PyCBC. We have another pipeline that's based on Gstreamer, which is actually really cool. I like that pipeline a lot.
30:21
And we use Python in that search as well to construct the Gstreamer pipelines. That's a streaming pipeline, so that one is actually used to detect events in real time as we take the data from the instrument. But this one is, you know, it's PyCBC,
30:40
and we have this LIGO algorithm library, which is a C library, which has all of these algorithms for generating what the waveforms look like and doing the templating to look for those signals in the data. That's called PyLAL. We also have a package called GWPy,
31:01
which is, you know, we use to retrieve data and do basic signal analysis and plotting. Of course, all of the plots you've seen, we're done with Matplotlib. I love Matplotlib. Who loves Matplotlib? All right, yay for Matplotlib.
31:20
Simulations, we do lots of simulations, like the S-X-S collaboration that made those really cool animations. They use Python interface to paraview. PyCat is an interface to this optical simulation thing that we use that simulates signals in the interferometer. Of course, like everybody else in the universe,
31:41
we're trying to get into machine learning. We're a little bit behind the curve, but, you know, we're ramping up. Outreach, IPython Notebook. Has anybody here used IPython Notebook? That's really cool. We love IPython Notebook. It's awesome.
32:00
And so we've been using that a lot, and it's been very useful in our outreach efforts. So I recommend people go to losc.ligo.org, L-O-S-C, the LIGO Open Science Center, and we have live IPython Notebooks where you can analyze the data yourself. It's the actual, basically you can get the actual data that we measure, which is just those, you know,
32:22
basically those WAV files which you can listen to, and you can filter it, and you can extract the signal and plot it. It's very cool, all in the IPython Notebooks. All right, the very last thing I wanna talk about is the instrument control. So I'm more on the instrument side. I like to help build the interferometers.
32:42
And so one of the things that I helped put together was our automation system. So we have this big optical experiment. It takes a lot of coordination to control all of the mirrors and the seismic isolation systems to get to the place where the instrument is sensitive,
33:03
most sensitive to detect the gravitational waves. And so I'll talk about that in a second. I'll just mention the one notable deficiency in Python where MATLAB still beats Python is in control system analysis. But hopefully that will change in the future.
33:20
Is that telling me something? All right, so automation. So there's this, I'll just talk about this really briefly, because I think it's a really cool usage of Python, and it's not because I made it. I swear. So it's called Guardian, and it's the automation system for LIGO.
33:42
It's a distributed hierarchy of state machine automatons. That's my fancy description of it. So this is kind of a schematic, very, very, very cartoonish schematic of the instrument. So here's the interferometer, you got the laser, you got the mirrors. Here you've got our analog digital interface
34:03
where these are just digital to analog converters that convert the electrical signals coming out of the instrument into digital signals. Here we have this real-time control system which I won't talk about, but which is really cool if anybody's interested in real-time signal analysis.
34:22
And then up at the top is this automation system. So each one of these blue dots represents one of these little automatons that is automating part of the real-time system. So it's basically like flipping, it's looking at signals and flipping switches and turning virtual knobs and stuff like that.
34:43
So in each one of these little blue dots, we have a state machine that represents the automation logic. Basically what happens is we say, oh, we wanna go to one of those states up there, and then this thing looks at this graph and says, okay, I'm gonna go this path to get over there.
35:05
And so this is all programmed in Python. So we have these Python modules that describe the instrument commands in these what we call state classes, and that's what this guard state is.
35:21
So guard state is just a class that defines one of those bubbles in that graph over to the right. It has a couple of methods that get overloaded. So safe is the name of a new state. Damped is the name of a new state. It has two methods, a main and a run method.
35:42
I won't get into the details of how those are executed, but basically they just have some commands in them. Flip this switch, set this gain to be something else, turn on these filters, stuff like that. Then we have edges, which is a list of tuples, which just represent connections between the ovals.
36:05
So you can see basically all of these arrows in the graph over to the right. And so this edge would connect the safe state to the damped state. And so then that whole thing,
36:20
those states and those edges is this state, what we call the state graph. So what Guardian does is it takes the modules that describe the state graphs, it imports them because Python is so powerful and you can get into the import mechanism so easily,
36:42
you can basically load the module, scan it for all of these guard state definitions, extract all the states, look for the edges definitions, put that all into the NetworkX module, which is a really sweet module for doing basically graph analysis, network analysis.
37:03
If anybody has to do network analysis, I highly recommend this package. And then it builds these graph representations. And so then what happens is that that graph then gets loaded into the automaton process
37:20
and that becomes like the brain of the automaton. And you say, hey, Guardian, go to state damped. And then Guardian looks at the graph and says, okay, I'm down here. And I can just very easily figure out how to get to the state that I wanna go to. And it just starts going, and it starts executing every state.
37:41
Once it's done with one state, it goes along the edge to the next one until it gets to the final place. And I think that the architecture of this is kinda cool because what we use is the multiprocessing library, which is awesome. I mean, Python rocks, just let me say it right now.
38:07
The interfaces to this stuff is just so clean, it's so nice. So the main process uses the multiprocessing to spawn off a worker process. And that worker process is the thing that actually does the execution of the user code,
38:22
that sends the commands. And you do it with the multiprocessing instead of the threading because that allows the daemon to have full control over the worker. If the worker is stuck or is blocking for some stupid reason because scientists aren't very good at writing computer code,
38:41
then it can just terminate it and respawn it and start over again. And we use the shared memory interface in the multiprocessing to exchange data between the two processes. So the commands to the worker go through the shared memory and then the status of the execution of the user code
39:02
goes back up through the shared memory. The worker process can catch all of the user exceptions, report them back to the daemon, the daemon won't die, it'll just keep sitting there and it'll report to the people in the control room, hey, somebody fucked up their code again, and makes an error message.
39:23
One thing that's kinda cool is that you can completely reload all the code on the fly. So you can just send a command to the daemon, it'll go and take all of the user code, that state graph, and it'll just take it, it'll take the, you can even reload,
39:42
if it's in the middle of executing a method on a class, you can even reload that same class. So what it'll do is it'll just wait till the method is done executing. In the meantime, it's taking all the attributes
40:00
of that class, stuffing it into the new version of the class, and then when that method is done, it just swaps it out and starts executing the new version of that method, the new version of that class with the new commands in it. Pretty cool, and we use this epics client server. This is something that's frequently used in physics
40:23
to, in large physics experiments, to do control of various, you know, control of big physics experiments. It's basically like a lightweight network message passing interface.
40:42
So that's it, just let me say, Python played a huge role in detection of gravitational waves in the analysis, in the control of the instruments, and on behalf of the entire field, I thank all of you. So thank you very much, stay tuned for more exciting news from LIGO.
41:07
Yes, thank you very much, James. I think this was, wasn't it amazing, like this view into one of the huge, biggest discoveries ever in physics. I mean, amazing, amazing talk. Thank you very much, James. I think you have a gift, haven't you?
41:22
We probably can take a few questions, if you. Oh, very good, thank you. Oh yeah, I'm happy to take questions. Yeah, we probably have like five minutes for questions. So, can you please come here? Yeah, please come to the front here.
41:40
So I've read, is it true, that when the first events came out, it was so huge that you thought it was a fake, some kind of elaborate prank. Are you asking what I personally thought? Because that's funny, because I thought exactly that. But I mean, many people in the collaboration, well, we of course behaved immediately
42:00
like it was a real event. But I was very, I don't know, it's too crazy, it's too perfect, it's too loud, it's not what we expected to see as our first event. So it took some of us, it took me, you know, like a month to be convinced that it was real. But you know, we did a lot of analysis.
42:20
I mean, we made the detection in September, and we did not announce until February. Yeah, exactly, they were rumors. We weren't just like sitting with our thumbs up our asses that whole time. We were analyzing the crap out of the data, trying to figure out, is this real? Are we completely convinced that this is a real gravitational wave? And then when we were ready and we had a really nice paper,
42:41
then we decided to announce. Yeah, that would be a lot, yeah. I mean, we thought a lot about that. Like, could it be malicious? Could somebody have, you know, somebody who's trying to get tenure, you know, snuck in? But it's too hard.
43:01
I mean, this is one of the, I mean, this is not the reason we made two detectors, but we make two detectors far away so that it's really difficult for any sort of terrestrial signal to look the same in both detectors. Basically impossible. Well, I have one more question about the actual utility of those detections.
43:24
Like, well, we know that you can now study some really radical events, but I've been reading about it and it's like, okay, sorry. Are those signals, are we capable of using those signals
43:41
to see behind things that we cannot see actually? Like, you can. Well, I mean, so, certainly, now that we've made the detections, so this is why I titled the talk The Dawn of Gravitational Wave Astronomy because the point is not just to make the one detection to prove that the gravitational waves exist,
44:00
that's very cool, but what we wanna do is we wanna see them routinely. That's why we continue to work on the detectors. We continue to try to make them better. So if we can see these events regularly, we will start to learn about what produced the events. I mean, you saw how much we learned just from this one event, right? We learned what are the masses of the black holes,
44:20
how far away they are. Just those things alone are very important information to astronomers because they tell us, the fact that we saw what appears to be three binary black hole mergers in our first observing run and not any neutron star mergers, which is something we thought we would see,
44:41
that tells us a lot about what's going on in the universe. So astronomically speaking, there's a lot of information that we can get from each of these signals and from the ensemble of all of the signals that we detect. Hi, Python two or Python three? Yeah, no, we're stuck. This is two seven, two seven.
45:01
We are slow to upgrade. We try to make things be, we're trying to do science, so we're not trying to go to the cutting edge all the time. I mean, obviously it would be, we will go to Python three eventually. I would like to go,
45:21
but you know, our system administrators are more conservative than me. Do you have kind of a model or measure how likely it would be to have this big event? How often would it repeat this big event? How likely that you just detect this one? The next one would be probably in a year or 10 years or something. So I mean, we had two and a half events in four months.
45:42
But do you have any models? The universe has this size and there are probably so many black holes, there should be so many. Sure, we have models, and we had models, but they had very big error bars because we don't know, we've never seen a gravitational wave, particularly for the black holes.
46:01
The error bars for the black holes were, there could be thousands a year or there could be zero. So they're like really huge error bars. We had no idea. And then we see two and a half in four months, so that's very promising. We will definitely see more as we continue to observe.
46:23
So the first detection was 1.3 billion light years away, three or 30 times the luminosity of the universe. What was the minimum safe distance for that? That's a good question. I think that that has been, right,
46:40
I don't have the answer to that off the top of my head, but I think that it's something like if you were within less than 1,000 kilometers from the event, you would actually feel the gravitational wave in your body. But remember, these gravitational waves are tiny. It's just like tiny fraction of a proton size
47:03
that's moving the instrument. So it's obviously impossible for humans to feel that unless you get really close to the black hole, but then at that point, I don't think I would wanna be there. I mean, it would be really cool, but it would be the last thing you see probably. That's a big relief, thank you. I thought there was no life left in that galaxy.
47:21
I wouldn't worry too much about it. I wouldn't worry too much. Okay, so first congratulations. It's really great to see finally some detection, confirmed detection in physics. So my question is how is the mass of the black holes model dependent? In a way, you have to assume, I guess, general relativity, you have to assume some lack of physics, you have to assume
47:42
some merging of black holes. I mean, all things that we don't really know that you kind of deduce all together through one observation. So how can this change? So what we deduce from the observation comes purely from general relativity. And black holes are actually very simple objects
48:02
in some sense because they're just purely mathematical. General relativity predicts that there would be these black holes if you have this very extreme curvature. And those, you know, they don't have many properties. They have a mass, they could have a charge. They almost in the real universe would not have a charge.
48:22
And they have a spin. They could be spinning. And these black holes were actually, we actually measured the spin of them as well. So there's really only these three parameters. I mean, there's the inclination of the spin relative to us. So we can use our knowledge of general relativity and these sort of simple black holes
48:42
to make predictions of the signals. And then that is what we, when we look at the data, we sort of reverse engineer what the signal looks like to extract what the parameters are. Okay. So you don't have to assume also a model for the evolution of the universe, for example.
49:01
No, we don't, we don't. Well, we do, we like to do a Bayesian analysis. So we have what we call priors where we make some assumption about what the distribution is, but we like to keep those assumptions to be very broad. So we don't want to bias our search. And so we like to assume that, you know, for the placement of the black holes in the universe,
49:23
we just assume that they're basically isotropic because we don't know, we don't know, we don't have, we don't yet have any reason to believe that they should preferentially be at some point. But the second black hole, the Boxing Day event, was also at a very similar distance,
49:41
basically 1.3 billion light years. So that's very interesting. We have two detections and they're both from basically the same distance away. They're also kind of similar masses. They're, you know, 10, 20 times, 30 times the mass of the sun. So, you know, this is what we're learning from these detections.
50:00
Okay, we have like time for three more short questions. So, Danielle. Danielle. Okay, very short. So, has. And Fabian and Fabio. Has your adoption of open source software also helped engender attitudes to opening the data
50:23
and the output of your science? Yeah, I would say, I would flip it, basically, and say that scientists are, by their nature, open. I mean, we, it's a little bit tricky because in academia, you know,
50:43
you have to, people get a little bit protective because they need their results so that they can get publications, so they can get tenure. But, you know, we also want to share. And so the, I think that, you know, we open source all of our software.
51:01
It's not just that we use open source software, but all the software that we write is also open source. So all of the, all of the, the Pi, CBC, Pi, LAL, all of our algorithms, those are on GitHub. This automation platform, that's freely available. You know, other scientific collaborations
51:21
can use them if they want. So we're firmly, firmly invested in open source. And obviously, we get so much benefit out of it. We, you know, I mean, if we, that's one thing that sucks about MATLAB, right? It's proprietary. We have to pay thousands of dollars, many, many thousands of dollars a year for licenses.
51:43
They've changed the APIs for no, apparently no reason, just because they think they should or make people want to buy a new version. They make two releases a year and, you know, you have to pay more. I mean, it's really annoying. It's really annoying to work with MATLAB, honestly. And so Python has just been huge
52:03
because the open source enables us to be more flexible. Very quickly, the things that you think are really missing are the main pain points
52:24
on the Python ecosystem, more specifically on the Pi data, you know, ecosystem that you could use and help. What can we do to improve? Oh, I don't know. Just keep doing what you're doing.
52:41
Yeah, I don't have anything in particular. I mean, there are certainly, like I mentioned, the controls analysis stuff. I mean, you know, there's lots of cool signal analysis stuff in SciPy. We would like, you know, to see more expansion of the capabilities there.
53:00
You know, we do a lot of very high performance computing stuff. We have, you know, big computer clusters where we do massively parallel analysis of the data. I don't know. I mean, that's one of the things that's so great about Python, is whenever, you know, I wanna do something
53:23
and I do a search, I can almost always find a quick, easy way to do it, so. So parallelism or? Yeah, the parallelism is a little bit, you know, I mean, it's kind of specialized because we need to parallelize across computers in a cluster.
53:40
So it's not the same, you know, I mean, obviously there are packages that help do that. We use this platform called Condor. I don't know if people have heard about that, but it's a job scheduling system for running analysis jobs on computer clusters. We don't, our cluster analysis is not terribly sophisticated.
54:02
It's not like these big numerical simulations where you have to do a lot of sharing of memory between processes spread across many nodes. We basically just, you know, give each computer node and each process running on each computer a little chunk of the data and say, you look for a gravitational wave here, you look for a gravitational wave here,
54:21
and we just, you know, massively parallel. So it's pretty straightforward what we have to do. The reconstruction of the information about the event, that's more complicated, right? Because we have, you know, this one small stretch of data where we know that there's an event
54:41
and we want to extract all the information from it. So we have to run a lot of models over it and, you know, do these integrals over all of these, you know, all of these different tests. So that's a little bit trickier. Okay, last question. Okay, I have a question about the visualization of the event that you had there.
55:02
It looked like, in your model, that there are two black holes which are rotating around each other about 30 times in five seconds. Is that something that actually happens? Those are slowed down, right? So they're actually, it's actually faster than, those are slower than real time. Yeah, they're very fast.
55:21
It's incredible, I mean, so I mean, one of the plots that I showed actually has, let me just go really quick, sorry to show one thing. I skipped it. Okay, look over here. This is the speed of the black hole,
55:44
the velocity of the black hole over the speed of light. So at the very end, the black holes, I mean, these are macroscopic, I mean, they're, you know, they're big. They're 30 solar mass things is moving at half the speed of light.
56:00
I mean, it is, it's nuts. I mean, what's going on in that region of space is, woo. That's crazy. Okay, woo. Thank you very much, Dave. Thank you, thank you.