コード例 #1
0
    def logistic(self, bact_name: str, time: float, pH: float,
                 temperature: float) -> list:
        """
        This formula calculates the growth of the bacteria based on the logistics formula.
        Here the growth is calculated until reaching the limiting factor.
            Using the formula:
                    y(t) = limiting factor/ (1+ initial value* exp^(-growth rate *t ))

        Return
        --------
            List
                 A list of the intervals of growth of the bacteria, that would be used by the plot of the graph
        """
        ant_lijst = []
        groeisFcator = EndResults.new_growth_rate(self, bact_name, pH,
                                                  temperature)
        beperkendeFactor = JsonChecker(bact_name, temperature, pH, "br", None)
        beperkendeFactor_is = beperkendeFactor.read_value_json()
        begingValue_is = JsonChecker(bact_name, None, None, "bw", None)
        begingValue = begingValue_is.read_value_json()

        for t in range(0, int(time)):
            ant = (beperkendeFactor_is[0] /
                   (1 + begingValue[0] * np.exp(-groeisFcator * t)))
            if ant <= beperkendeFactor_is[0]:
                ant_lijst.append(ant)
        return ant_lijst
コード例 #2
0
    def temp_growth_rate(
        self,
        bact_name: str,
        pH: float,
        end_time: float,
        temp_check: list,
    ) -> list:
        """
        This formula calculates the growth factor per temperature difference. the temperature rises one grade up every
         hour, until the max temperature is reached.
         The temperatures are shown on the x-axis and the growth factors on the y-axis.
           Using the function : new_growth_rate
         Return
         ------
            list
                 A list with growth factors that were calculated in the algorithm
         """

        beginRange, eindRange = 0, 0
        list = []
        tijd_lijst = []
        if temp_check is not None:
            if len(temp_check) == 3:
                beginRange = temp_check[0]
                eindRange = temp_check[2] + 1

            elif len(temp_check) == 2:
                beginRange = temp_check[0]
                eindRange = temp_check[1] + 1

            elif len(temp_check) == 1:
                beginRange = temp_check[0]
                eindRange = temp_check[0] + 1

        begingValue_is = JsonChecker(bact_name, None, None, "bw", None)
        begingValue = begingValue_is.read_value_json()

        beperkingsFactor_is = JsonChecker(bact_name, None, None, "br", None)
        beperkingsFactor = beperkingsFactor_is.read_value_json()
        groei_lijst = []

        for time in range(0, int(100) + 1):
            tijd_lijst.append(time)
        for temp in range(int(beginRange), int(eindRange) + 1):
            if list:
                if list[-1] <= beperkingsFactor[0]:
                    if tijd_lijst:
                        groeisFactor = EndResults.new_growth_rate(
                            self, bact_name, pH, temp)
                        groei_lijst.append(groeisFactor)
                        list.append(beperkingsFactor[0] /
                                    (1 + begingValue[0] *
                                     np.exp(-groeisFactor * tijd_lijst[0])))
                        tijd_lijst.pop(0)
            else:
                list.append(0)
        return groei_lijst
コード例 #3
0
    def new_growth_rate(self, bact_name: str, pH: float,
                        temperature: float) -> list:
        """
        Here the growth factor is calculated at a certain temperature and ph value.
        Using the CTPM equation :

            μ max (T, pH) = CTPM(T, pH) = μ opt t(T)* p(pH)

            t(T)= (T - T MAX)(T - T MIN)**2 / (T opt 2 T min) [(Topt - Tmin)(T - Topt) - (Topt - Tmax) (Topt + Tmin - 2T)]

             p(pH) = (pH - pH min) (pH - pH max)/(pH - pH min)(pH - pH max) - (pH - pH opt) **2

        Return
        --------
            Float
                A float of the new growth rate

        """
        temp_check = JsonChecker(bact_name, temperature, pH, "temp",
                                 temperature)
        temp_waardes = temp_check.read_value_json()

        ph_check = JsonChecker(bact_name, temperature, pH, "ph", pH)
        pH_waardes = ph_check.read_value_json()

        groeisFcator = JsonChecker(bact_name, temperature, pH, "gr", None)
        groeisFcator_is = groeisFcator.read_value_json()

        # max growth rate(T, pH) = CTPM(T, pH)= optimum growth rate t(T) p(pH)

        # temerature t(T)
        # de noemer stukje 1
        tt = ((temp_waardes[1] - temp_waardes[0]) *
              (temperature - temp_waardes[1]) -
              (temp_waardes[1] - temp_waardes[2]) *
              (temp_waardes[1] + temp_waardes[0] - 2 * temperature))

        # de noemer stukje 2
        tt2 = ((temp_waardes[1] - temp_waardes[0]) * tt)
        # de teller
        tt3 = ((temperature - temp_waardes[2]) *
               (temperature - temp_waardes[0])**2 / tt2)

        # pH p(pH)
        # de noemer
        phh = ((pH - pH_waardes[0]) * (pH - pH_waardes[2]) -
               (pH - pH_waardes[1])**2)
        # de teller
        phh2 = ((pH - pH_waardes[0]) * (pH - pH_waardes[2]) / phh)

        # new groei factor
        newgroeiFactor = groeisFcator_is[0] * tt3 * phh2

        return newgroeiFactor
コード例 #4
0
    def logstic_curve(self, bact_name: str, time: float, pH: float,
                      temperature: float) -> list:
        """
        This formula use the logistic formula to calculate the growth until the limiting factor.
        Then it would calculate the death phase of the bacteria.

        Return
        --------
            List
                A list of the intervals of growth of the bacteria, that would be used by the plot of the graph
        """
        list = EndResults.logistic(self, bact_name, time, pH, temperature)
        groeisFcator = EndResults.new_growth_rate(self, bact_name, pH,
                                                  temperature)
        beperkendeFactor = JsonChecker(bact_name, temperature, pH, "br", None)
        beperkendeFactor_is = beperkendeFactor.read_value_json()
        lijstDeath = []
        lijstDeath.append(list[-1])

        while lijstDeath[-1] > list[0]:
            # zolang de deathwaarde grooter of glijk is aan de beginwaarde van de groei is:
            antwoord = lijstDeath[-1] - (groeisFcator * len(lijstDeath))
            if beperkendeFactor_is[0] >= antwoord >= list[0]:
                # als de antwoord niet gelijk of groter aan de beperkende factor is
                lijstDeath.append(antwoord)
            else:
                lijstDeath.append(list[0])
                break
        for item in lijstDeath:
            list.append(item)
        return list
コード例 #5
0
class TestJsonChecker(TestCase):
    def setUp(self) -> None:
        #tempratuur testen
        self.readeersteFile_temp = JsonChecker(bacteria_name="xx",
                                               temperature=10,
                                               pH=10,
                                               item="temp",
                                               inputWaarde=10)
        self.readeersteFile_temp_O2 = JsonChecker(bacteria_name="xx",
                                                  temperature=4,
                                                  pH=10,
                                                  item="temp",
                                                  inputWaarde=4)
        self.readeersteFile_temp_O3 = JsonChecker(bacteria_name="xx",
                                                  temperature=37,
                                                  pH=10,
                                                  item="temp",
                                                  inputWaarde=37)
        self.readeersteFile_temp_O4 = JsonChecker(bacteria_name="xx",
                                                  temperature=45,
                                                  pH=10,
                                                  item="temp",
                                                  inputWaarde=45)
        self.readeersteFile_temp_O5 = JsonChecker(bacteria_name="xx",
                                                  temperature=50,
                                                  pH=10,
                                                  item="temp",
                                                  inputWaarde=50)

        self.readeersteFile_temp1 = self.readeersteFile_temp.read_value_json()
        self.readeersteFile_temp_2 = self.readeersteFile_temp.values_check()
        self.readeersteFile_temp_O2_1 = self.readeersteFile_temp_O2.values_check(
        )
        self.readeersteFile_temp_O3_1 = self.readeersteFile_temp_O3.values_check(
        )
        self.readeersteFile_temp_O4_1 = self.readeersteFile_temp_O4.values_check(
        )
        self.readeersteFile_temp_O5_1 = self.readeersteFile_temp_O5.values_check(
        )

        #ph testen
        self.readeersteFile_pH = JsonChecker(bacteria_name="xx",
                                             temperature=10,
                                             pH=10,
                                             item="ph",
                                             inputWaarde=10)
        self.readeersteFile_pH_O2 = JsonChecker(bacteria_name="xx",
                                                temperature=10,
                                                pH=3.5,
                                                item="ph",
                                                inputWaarde=3.5)
        self.readeersteFile_pH_O3 = JsonChecker(bacteria_name="xx",
                                                temperature=10,
                                                pH=5,
                                                item="ph",
                                                inputWaarde=5)
        self.readeersteFile_pH_O4 = JsonChecker(bacteria_name="xx",
                                                temperature=10,
                                                pH=4.5,
                                                item="ph",
                                                inputWaarde=4.5)
        self.readeersteFile_pH_O5 = JsonChecker(bacteria_name="xx",
                                                temperature=10,
                                                pH=20,
                                                item="ph",
                                                inputWaarde=20)

        self.readeersteFile_pH1 = self.readeersteFile_pH.read_value_json()
        self.readeersteFile_pH2 = self.readeersteFile_pH.values_check()
        self.readeersteFile_pH_O2_1 = self.readeersteFile_pH_O2.values_check()
        self.readeersteFile_pH_O3_1 = self.readeersteFile_pH_O3.values_check()
        self.readeersteFile_pH_O4_1 = self.readeersteFile_pH_O4.values_check()
        self.readeersteFile_pH_O5_1 = self.readeersteFile_pH_O5.values_check()

        #aw_testen
        self.readeersteFile_aw = JsonChecker(bacteria_name="xx",
                                             temperature=10,
                                             pH=10,
                                             item="aw",
                                             inputWaarde=10)
        self.readeersteFile_aw_1 = self.readeersteFile_aw.read_value_json()

    def tearDown(self) -> None:
        self.readeersteFile_temp1 = None
        self.readeersteFile_temp_2 = None
        self.readeersteFile_temp_O2_1 = None

        self.readeersteFile_pH1 = None
        self.readeersteFile_pH2 = None
        self.readeersteFile_pH_O2_1 = None

    def test_read_json(self):
        # temp lezen
        self.assertEqual(self.readeersteFile_temp1, [6.0, 37.0, 45.0])
        # ph lezen
        self.assertEqual(self.readeersteFile_pH1, [4.0, 5.0, 10.0])
        #aw lezen
        self.assertEqual(self.readeersteFile_aw_1, [0.85])

    def test_value_check(self):
        #temp check
        # temp is grooter dan de min en kleiner dan de optimum
        self.assertEqual(self.readeersteFile_temp_2, [10.0, 37, 45.0])
        # temp is kleiner dan de min
        self.assertRaises(Exception, self.readeersteFile_temp_O2_1)
        # temp is gelijk aan de optimum
        self.assertEqual(self.readeersteFile_temp_O3_1, [37.0, 45.0])
        # tep is gelijk aan de max
        self.assertEqual(self.readeersteFile_temp_O4_1, [45.0])
        # temp is grooter dan de max
        self.assertRaises(Exception, self.readeersteFile_temp_O5_1)

        # ph check
        # ph is gelijk aan de max
        self.assertEqual(self.readeersteFile_pH2, [10.0])
        # ph is kleiner dan de min
        self.assertRaises(Exception, self.readeersteFile_pH_O2_1)
        # ph is gelijk aan de optimum
        self.assertEqual(self.readeersteFile_pH_O3_1, [5.0, 10.0])
        # ph is kleiner dan de optimum en groter dan de min
        self.assertEqual(self.readeersteFile_pH_O4_1, [4.5, 5.0, 10.0])
        # ph is grooter dan de max
        self.assertEqual(self.readeersteFile_pH_O5_1, None)
コード例 #6
0
        def findJson(input):
            """
            De input van de gebruiker wordt naar deze functie doorgestuurd om vervolgens de bijhornde info in de json bestand op te zoeken.
                Er wordt ook een foto van de bacterie laten zien als het bestaat.
                Voor het gevaal dat de gebruiker een bacterienaam invoert die niet in de json bestanden bestaat, gebruik ik een try except
            """
            try:
                with open("../Extra bestanden/" + str(input) + ".json",
                          "r") as f:
                    info = json.load(f)
                    informatieVanJson = info["info"]
                    infoUitprinten = tk.Label(frameMideen,
                                              text="",
                                              font='Arial 18 ',
                                              bg=bg_background,
                                              fg=fg)
                    fotolabel = tk.Label(
                        frameMideen,
                        text="Foto van de bacterie",
                        bg=bg_background,
                        fg="#FFEEDD",
                    )
                    naamUitprinten = tk.Label(frameMideen,
                                              text=str(input),
                                              font='Arial 20 bold',
                                              bg=bg_background,
                                              fg=fg)
                    omstandigheden = tk.Label(frameMidenMiden,
                                              text="\nOmgevingsfactoren",
                                              font='Arial 20 bold',
                                              bg=bg_background,
                                              fg=fg)
                    infoUitprinten.config(text=informatieVanJson)
                    omstandigheden.pack(side=tk.LEFT,
                                        fill=tk.X,
                                        padx=5,
                                        ancho="nw")

                    items = ["temp", "ph", "aw"]
                    for item in items:
                        maxminInfo = tk.Label(frameMidenMiden,
                                              text="",
                                              font='Arial 18 ',
                                              bg=bg_background,
                                              fg=fg)
                        jsonjsno = JsonChecker(str(input), None, None, item,
                                               None)
                        maxenmin = jsonjsno.read_value_json()

                        if len(maxenmin) == 3:
                            maxminInfo.config(
                                text=
                                f"De {str(item)} waarde is:\n de maximum gelijk aan {str(maxenmin[2])} garde"
                                f" \nde mimium is gelijk aan {str(maxenmin[0])} grade\n en de optimum waarde is"
                                f": {str(maxenmin[1])} grade.")
                            maxminInfo.pack(side=tk.LEFT,
                                            fill=tk.X,
                                            padx=5,
                                            ancho="nw")

                        else:
                            maxminInfo.config(
                                text=
                                f"De {str(item)} waarde is :\n {str(maxenmin[0])} grade.\n\n"
                            )
                            maxminInfo.pack(side=tk.BOTTOM,
                                            fill=tk.X,
                                            padx=5,
                                            ancho="nw")

                        print(maxenmin)

                    naamUitprinten.pack(side=tk.LEFT,
                                        fill=tk.X,
                                        padx=5,
                                        ancho="nw")
                    infoUitprinten.pack(side=tk.LEFT,
                                        fill=tk.X,
                                        padx=5,
                                        ancho="nw")

            except FileNotFoundError:
                messagebox.showwarning(
                    "",
                    "We hebben geen informatie over die bacterie kunnen vinden"
                )

            try:
                img = ImageTk.PhotoImage(
                    Image.open("../Extra bestanden/" + str(input) + ".png"))
                panel = tk.Label(frameMideen, image=img)
                panel.image = img
                fotolabel.pack(side=tk.TOP, fill=tk.X, padx=5, ancho="nw")
                panel.pack(side="bottom", ancho="center")
            except FileNotFoundError:
                print("file not found")
コード例 #7
0
    def log_growth(self, bact_name: str, time: float, pH: float,
                   temperature: float) -> list:
        """
        This function calculates the growth of the bactria on the basis of 4 phases:
            Lag phase, logarithmic phase, the stationary phase and the death phase.
            Using this equation: Ln N -Ln N0 = μ *(t-t0)
                                where:
                                   μ stands for the growth rate per h^-1
                                   N stands for the number of CFU / ml at time t
                                   N0 stands for the initial number of CFU / ml at time t0
                                   t stands for time
        Parameters
        ----------
        bact_naam: String
            The name of a bacteria
        time: Float
             The user input of end time

        pH: Float
             The user input of the PH

        temperature: Float
             The user input for the temperature

        ant_lijst: List
             The list where the results of the algorithm are stored

        Return
        --------
            List
                A list of the intervals of growth of the bacteria, that would be used by the plot of the graph
        """

        ant_lijst, lijstDeath = [], []
        beperkendeFactor = JsonChecker(bact_name, temperature, pH, "br", None)
        beperkendeFactor_is = beperkendeFactor.read_value_json()
        lnN0_ = JsonChecker(bact_name, temperature, pH, "bw", None)
        lnN0 = lnN0_.read_value_json()
        ant_lijst.append(lnN0[0])

        # de specfieke groeifactor uitrekenen
        newgroeiFactor = EndResults.new_growth_rate(self, bact_name, pH,
                                                    temperature)

        for t in range(0, int(time) + 1):
            lnN = (newgroeiFactor * t) + lnN0[0]
            if lnN < beperkendeFactor_is[0]:
                ant_lijst.append(lnN)
            else:
                ant_lijst.append(beperkendeFactor_is[0])
        lijstDeath.append(ant_lijst[-1])
        if ant_lijst[-1] == beperkendeFactor_is[0]:
            while lijstDeath[-1] >= lnN0[0]:
                antwoord = lijstDeath[-1] - (newgroeiFactor * len(lijstDeath))
                if antwoord >= lnN0[0]:
                    lijstDeath.append(antwoord)
                else:
                    lijstDeath.append(lnN0[0])
                    break
            for item in lijstDeath:
                ant_lijst.append(item)
        return ant_lijst