Objekt-orienterede opgaver

Opgave 4.1

Skriv en klasse, hvis objekter er trekanter i -planen. Et objekt initialiseres ved angivelsen af trekantens tre hjørnepunkter samt evt. af en farve som trekanten skal tegnes med. Klassen skal have følgende attributter:
  1. .points: de tre hjørner
  2. .cm: massemidtpunktet
  3. .color: farven tegneobjektet skal have. Hvis objektet får tildelt en ny værdi til denne attribut (fx som det sker her) skal klassen sørge for at såfremt trekanten allerede er tegnet, så opdateres tegneobjektet for trekanten med den nye farve (se hvordan farven skiftes for noget tegnet med fill i denne how to).
  4. .triangle: tegneobjektet for trekanten
  5. .cross: tegneobjektet for et kryds afsat i massemidtpunktet
Klassen skal have følgende metoder:
  1. .draw(ax): tegner trekanten i Axis-objektet ax. Hvis trekanten allerede er tegnet flyttes den. Trekanten tegnes med fill og der afsættes et kryds på massemidtpunktet.
  2. .move(r): flytter trekanten vektoren r.
Tegn en figur med trekanter beskrevet som instanser af ovenstående klasse. Kald de forskellige metoder og plot figuren. Konstatér at alt virker som det skal.
Så når klassen er skrevet skal du fx kunne gøre følgende: 
P1 = np.array([2,1])
P2 = np.array([4,3])
P3 = np.array([1,4])
points = np.array([P1,P2,P3])
t = Trekant(points)
t.draw(ax)

Figure 1 

r = np.array([2,1])
t.move(r)
fig

Figure 2 

t.color = 'orange'
fig

Figure 3 

t2 = Trekant(points)
t2.color = 'chocolate'
t2.draw(ax)
fig

Figure 4

Opgave 4.2

Denne opgave omhandler et fjedernetværk. Netværket har fem knudepunkter og 8 fjedre. Fjedrene sidder mellem følgende par af knuder (nummereret fra 0): , , , , , , og . Knuderne er til at begynde med placeret tilfældigt med - og -koordinater, der er trukket fra en uniform fordeling af flydende kommatal mellem og . Det kunne se ud som illustreret her:

Figure 5

men vil skifte fra gang til gang du kører din løsning til opgaven.
a)
Skriv to python objekt-klasser, der kan håndtere hhv en knude og en fjeder.
For knude-klassen gælder:
  1. ved instantiering trækkes de tilfældige koordinater fra fordelingen og gemmes som attributter på objektet.
  2. ved instantiering plottes knuden (det hvide tal, der er plottet ovenfor er ikke vigtigt) og plotte-objektet gemmes som en attribut, så der senere kan flyttes på tegningen.
  3. der er en metode, .plot(), der flytter knuden på tegningen til den aktuelle position givet ved attributterne med koordinaterne.
  4. der er en metode, .optimer(all_fjedre), der midlertidigt ændrer knudens position ved at lægge tilfældige tal til hhv - og -koordinaterne. De tilfældige tal er normaltfordelte omkring nul med en standardafvigelse på . Efter ændringen af positionen regnes det ud om energien af fjeder-netværket er gået ned. Er den det beholdes de nye koordinater. Er den det ikke reetableres de tidligere koordinater. Hint: husk det med .copy() for at få en kopi af et numpy-array og ikke blot endnu et navn for det.
For fjeder-klassen gælder:
  1. ved instantiering skal et fjeder-objekt kende de to objekter for knuderne som fjederen sidder imellem. Disse to objekter gemmes som attributter så de kan tilgås senere.
  2. ved instantiering tegnes en stiplet streg mellem knuderne. Plotte-objektet for stregen gemmes som attribut, så stregen senere kan flyttes.
  3. der er en metode, .energi(), der kan regne energien af fjederen ud. Fjederkonstanten er og ligevægtslængden er .
  4. der er en metode, .plot(), der flytter den stiplede streg til den aktuelle placering af fjederen.
Når klasserne er defineret skal du kunne køre denne kode (eller noget, der ligner, du må gerne tilpasse den): 
# opret knuderne og gem dem i en liste, hvor indexet har en betydning
knuder = []
for i in range(5):
    knuder.append(Knude())

# fjedrene sidder mellem knuder med disse indices:
forbindelser = [[0, 1],
                [1, 2],
                [2, 3],
                [3, 0],
                [0, 4],
                [1, 4],
                [2, 4],
                [3, 4]]

# sæt fjedrene op
fjedre = []
for indexA,indexB in forbindelser:
    knudeA = knuder[indexA]
    knudeB = knuder[indexB]
    fjedre.append(Fjeder(knudeA,knudeB))
Du har nu en tegning af fjedersystemet, da såvel knuder som fjedre tegnede sig selv ved instantieringen.
b)
Tjek at energi-beregningen og flytte-metoden virker ved at skrive noget i stil med: 
energi_foer = np.sum([fjeder.energi() for fjeder in fjedre])

N_flytninger = 5
for _ in range(N_flytninger):
    for knude in knuder:
        knude.optimer(fjedre)

energi_efter = np.sum([fjeder.energi() for fjeder in fjedre])  
print(energi_foer,energi_efter)
c)
Tjek at opdatering af plottet virker ved at skrive: 
for knude in knuder:
    knude.plot()
for fjeder in fjedre:
    fjeder.plot()
fig
d)
Lav en animation af optimeringen af fjedernetværket:

Figure 6

e)
Slå dig løs og lav noget sjovt med opgaven. Du kan fx farve fjedrene alt efter deres energi. Du kan ændre energi-udtrykket så alle knuder frastøder hinanden for meget korte afstande (Hint: brug et Lennard-Jones udtryk til det).
Du kan også indføre andre betingelser for optimeringen - lade nogle af knuderne være stationære og lade andre knuder bidrage til energien ved at have en masse og være i et tyngdefelt. Så kan du finde kædelinien:

Figure 7

Opgave 4.3

Skriv en klasse, hvis objekter er random walkers i -planen. Alle walkere starter i begyndelsespunktet, .
Klassen skal have følgende attributter:
  1. .r: walkerens position
  2. .col: walkerens farve
Klassen skal have følgende metoder:
  1. .move(): flytter walkeren distancen i en tilfældig retning
  2. .distance(): returnerer hvor langt walkeren er fra
Hint: Benyt komma-tal når du initialiserer r, altså: skriv np.array([0.,0.]) fremfor np.array([0,0]). Ellers kan der nemt opstå et type-problem for NumPy hvis den skal starte med heltal og regne videre med kommatal.
a) Start 100 random walkere ud. Plot dem med scatter. Flyt dem allesammen én gang. Opdatér plottet. Gentag 100 gange.

Figure 8

b) Plot som funktion af tiden hvor langt en walker i middel har flyttet sig. Du får en monotont stigende kurve. Plot logaritmen af de to samme størrelser og konstatér at du får en ret linie.

Figure 9

c) Udarbejd en animation af forløbet.

Figure 10

Hint: Når man plotter med scatter får man et PathCollection objekt retur. Du kan lave en generel plotte-funktion, der ser således ud, hvor du selv skal udfylde for - og -værdierne: 
def plot_all_walkers(ax,walkers_to_plot):
    artist = ax.scatter(# x-værdier
                        # y-værdier
                  color=[w.col for w in walkers_to_plot])
    return artist
Dette objekt kan du så udskifte - og -værdier for i din update-funktion, som du skriver i forbindelse med animationen. Det kunne se således ud: 
artist.set_offsets([w.r for w in walkers])
da den skal have et array af -værdier.

Opgave 4.4

a) Skriv en klasse, der håndterer et vandmolekyle i -planen. Klassen skal have følgende attributter:
  1. .r: Positionen, , af ilt-atomet i vandmolekylet.
  2. .theta: Vinklen, , som bindingen mellem ilt-atomet og det første brint-atom i vandmolekylet danner til -aksen. Når .theta ændres skal attributterne .r_H1 og .r_H2 genberegnes.
  3. .r_H1: Den beregnede position af det første brint-atom når ilt-brint bindingslængden er Å.
  4. .r_H2: Den beregnede position af det andet brint-atom. Der skal være vinklen mellem de to ilt-brint-bindinger i molekylet.
  5. .ax: Axis-objektet som molekylet er plottet i.
  6. .artists: En liste med tre Line2D-objekter, en rød markør i første objekt og to hvide markører i de andre to objekter.
Desuden skal klassen have to metoder:
  1. .rattle(): Når denne kaldes skal ændres med , hvor .
  2. .draw(new_ax): Hvis objektets .ax attribut endnu ikke er sat skal den sættes til new_ax og de tre kugler, en rød og to hvide, skal tegnes og gemmes som en liste i .artists. Hvis new_ax udelades skal de tre allerede tegnede kugler (som så kan tilgåes via listen .artists) opdateres til de aktuelle positioner givet ved .r, .r_H1 og .r_H2.
b) Opret 9 objekter med hvert deres vandmolekyle havende -værdier for alle kombinationer af og . Benyt tilfældige -værdier.

Figure 11

c) Beregn energien af de 9 vandmolekyler ved hjælp af denne funktion, der tager en liste af de 9 vandmolekyle-objekter som input: 
def calculate_total_potential_energy(molecules):
    W_OO = 0
    W_HO = -0.2
    W_HH = 0.1
    u = 0
    for m1 in molecules:
        r1_O = m1.r
        r1_H1 = m1.r_H1
        r1_H2 = m1.r_H2
        for m2 in [m for m in molecules if m != m1]:
            r2_O = m2.r
            r2_H1 = m2.r_H1
            r2_H2 = m2.r_H2
            for r1,r2,W in [(r1_O,r2_O,W_OO),
                            (r1_O,r2_H1,W_HO),
                            (r1_O,r2_H2,W_HO),
                            (r1_H1,r2_O,W_HO),
                            (r1_H1,r2_H1,W_HH),
                            (r1_H1,r2_H2,W_HH),
                            (r1_H2,r2_O,W_HO),
                            (r1_H2,r2_H1,W_HH),
                            (r1_H2,r2_H2,W_HH),
                           ]:
                u += W / np.linalg.norm(np.array(r1)-np.array(r2))
    return u
Bemærk: funktionen er ikke en del af klassen.
d) Kald .rattle()-metoden for et eller flere af molekylerne og gentage spørgsmål c). Sammenlign energien for de forskellige molekyle-arrangementer der opstår. Hvis brint-atomerne peger mod ilt-atomerne bliver den potentielle energi optimeret, dvs. lavest muligt. Det ser fx således ud:

Figure 12

d) Foretag nu optimeringen automatisk med et par nestede for-løkker. I inderste løkke loopes over alle molekyler, i yderste løkke loopes over et antal forsøg. For hvert molekyle i inderste løkke skal du holde styr på vinklen og molekylernes potentielle energi inden og efter en ændring af vinklen ved kald af .rattle(). Energi-ændringen betegnes . Såfremt energi-ændringen er negativ eller opfylder:
hvor er et tilfældigt tal (uniformt fordelt mellem og ) og hvor er en konstant, så beholdes ændringen af ellers sættes molekylets -værdi tilbage til hvad den var inden kaldet af .rattle(). Metoden der benyttes kaldes Metropolis Monte Carlo-metoden. Alt efter værdien af vil den kunne overkomme små barrierer og kunne optimere en atomar struktur mod en lav-energi struktur. Her vises energien for 100 af de nestede løkker (2 ydre gentagelser, ét opdateringsforsøg per molekyle i den inde løkke). I den første halvdel af simuleringen er . I den anden halvdel er den :

Figure 13

e) Lav en animation af din automatiske optimering. Hint: Placér Metropolis Monte Carlo optimeringen inde i den funktion, update, som animation.FuncAnimation kalder når animationen foretages.

Opgave 4.5

I denne opgave skal du arbejde med klynger af atomer i -planen. Det kunne se således ud for klynger med 12 atomer, hhv. før og efter at strukturen af klyngen er optimeret med hensyn til den potentielle energi:

Figure 14

Potentialenergien af et atom i en klynge skal vi beregne som summen af alle par-vise vekselvirkninger med andre atomer, som atomet indgår i. Til opgaven skal benyttes approximationen med Lennard-Jones potentialet, hvor to atomer i afstanden vekselvirker med:
hvor eV og Å.
Til at optimere strukturen af en klynge af atomer skal vi benytte Metropolis Monte-Carlo metoden. Her beregnes energi-ændringen, , som et atom forårsager hvis det flyttes en normaltfordelt afstand i en vilkårlig retning. Hvis energi-ændringen er negativ accepteres flytningen af atomet. Flytningen accepteres også hvis energi-ændringen er positiv, men dog opfylder:
hvor er et tilfældigt tal (uniformt fordelt mellem og ) og hvor er en konstant. Hvis ingen af de to betingelser er opfyldt forkastes flytningen af atomet. Man vil typisk loope over alle atomer et stort antal gange i forbindelse med en Metropolis Monte-Carlo simulering og evt. mindske undervejs. Her er et eksempel for 12 atomer og eV:

Figure 15

Her kommer opgaven:
a) Skriv en klasse, hvis objekter er atomer i -planen. Klassen skal definere følgende attributter på objekterne:
  1. .r: NumPy array med atomets position.
  2. .artist: Et Line2D objekt når atomet er blevet plottet som en farvet skive.
Klassen skal derudover definere følgende metoder:
  1. .plot(ax): Plotter atomer som et Line2D-objekt i Matplotlib Axis-objektet, ax. Skal gemme Line2D-objektet som ovennævnte attribut .artist.
  2. .get_potential_energy(other_atoms): Skal beregne energien af alle de kemiske bindinger af Lennard-Jones typen, der brydes hvis dette atom flyttes fra en klynge af atomer givet ved listen af atom-objekter, other_atoms.
  3. .monte_carlo_step(other_atoms): Flytte et atom en normalt-fordelt distance med amplitude i en vilkårlig retning. Flytningen accepteres kun såfremt den leder til en lavere energi eller Metropolis Monte-Carlo-betingelsen er opfyldt.
b) Lav en klynge af 4 atomer ved at lave 4 instanser af ovenstående klasse. Sæt de 4 objekter sammen i en liste så de kan håndteres i koden. Plot klyngen som du har initialiseret den. Kald .monte_carlo_step(other_atoms) for ét af atomerne et antal gange og demonstrér at potentialenergien for pågældende atom mindskes.
c) Skriv din kode, så du looper over alle atomer og optimerer hele klyngen. Plot klyngen før og efter optimeringen.
d) Udarbejd et katalog over optimale strukturer af klynger med fra 4 til mindst 12 atomer, men gerne højere. Med katalog menes billeder af de bedste strukturer du har fundet. Benyt Python-kommandoer til at håndtere disse billeder. Lav gerne en stor sammensat figur med mange paneler som i en tidligere aflevering.
e) Lav en animation af en af dine Monte Carlo-simuleringer.