Kuramoto/Project-Kuramoto.py at master · AndrewJSON/Kuramoto · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

import numpy             as np
import matplotlib.pyplot as mp

import Kuramoto         as ku
import InitGenerator    as ig
import CSV_handler      as ch
import CSV_vectorWriter as vw
import CSV_vectorReader as vr
import OrderParameter   as op


class ProjectKuramoto:

    def __init__(self, _kuramoto, _initGenerator, _csvHandler, _numOsc=50):

        self.kuramoto         = _kuramoto
        self.init             = _initGenerator
        self.csvHandler       = _csvHandler

        self.numOsc           = 0
        self.timeSteps        = 0
        self.allResults       = None

        self.setNumberOfOscillators( _numOsc )


    def setNumberOfOscillators(self, _numOsc):

        self.numOsc   = _numOsc

        self.kuramoto.setNumberOfOscillators( _numOsc )
        self.init.setNumberOfOscillators( _numOsc )
        self.csvHandler.setVectorLength( _numOsc )

        print("\nNumber of oscillators set to", self.numOsc, "\n")


    def solveMultipleRunsWithSelfFeedingInit(self, _runs, _timeStepsToStore):

        randomInit = self.init.makeRandomInitConditions()
        self.kuramoto.solveKuramoto( self.timeSteps, randomInit )
        newInitValue = self.getLastTimeStep()

        print("last result", newInitValue)

        for i in range(0, _runs):

            self.kuramoto.solveKuramoto( self.timeSteps, newInitValue )

            print("current sigma", self.kuramoto.sigma)   #TODO
            print("current result", i, ":", newInitValue) #TODO

            t1 = self.timeSteps - _timeStepsToStore - 1
            t2 = self.timeSteps - 1

            phases = self.kuramoto.getResults( 'Phases', (t1,t2) )
            self.saveRun( phases, 'phase-results.csv' )

            self.kuramoto.sigma += 0.1
            newInitValue = self.getLastTimeStep()


    def saveRun(self, _resultsToSave, _fileName):

        self.csvHandler.appendVectorsToFile( _resultsToSave, _fileName )
        #self.csvHandler.writeVectorsToNewFile( _resultsToSave, _fileName )


    def getRunFromFile(self, _fileName, _blockSize):
        return self.csvHandler.getVectorBlockFromFile( _fileName, _blockSize )


    def solveKuramotoWithGivenInit(self, _numOfTimeSteps, _init):
        self.kuramoto.solveKuramoto( _numOfTimeSteps, _init )


    def getLastTimeStep(self):

        #FIXME cake slice: getSingleResult vs. getResultTimeInterval
        lastTimeStep = (self.timeSteps - 1, self.timeSteps)
        return self.kuramoto.getResults( "all", lastTimeStep )[0]


    def getPhaseResults(self, _timeIndex=None):
        return self.kuramoto.getPhaseResults( _timeIndex )


    def getCouplingResults(self, _timeIndex=None):
        return self.kuramoto.getCouplingResults( _timeIndex )


def prepareProject():

    a      = 0.3*np.pi
    e      = 0.01
    b      = 0.23*np.pi
    sigma  = 1.0
    numOsc = 50

    myKuramoto1     = ku.Kuramoto(a, e, b, sigma)
    myInitGenerator = ig.InitGenerator()
    myVectorWriter  = vw.CSV_vectorWriter()
    myVectorReader  = vr.CSV_vectorReader()
    myCSV_handler   = ch.CSV_handler( myVectorWriter, myVectorReader )

    return ProjectKuramoto( myKuramoto1, myInitGenerator, myCSV_handler, numOsc )

if __name__ == '__main__':


    myProjectKuramoto = prepareProject()
    myOrderParameter = op.OrderParameter()

    myProjectKuramoto.timeSteps = 200

    timeStepsToStore = 50
    numOfRuns        = 3

    myProjectKuramoto.solveMultipleRunsWithSelfFeedingInit( numOfRuns       ,\
                                                            timeStepsToStore )

    for runNumber in range(0, numOfRuns):

        startReadOffset = runNumber * timeStepsToStore
        start = startReadOffset
        stop = startReadOffset + timeStepsToStore

        block = myProjectKuramoto.csvHandler.reader.getVectorBlock( start, stop )
        orderParameter = myOrderParameter.SumUpOrderMatrix_Elements( block )
        print("Order Parameter of run ", runNumber, orderParameter)

''' END '''