def _visualize(self, obj, **kwargs): fnResults = self.protocol._getPath("results.txt") if exists(fnResults): X, Y, _, _ = self.protocol.getXYValues(False) minX = min(X) maxX = max(X) step = (maxX - minX) / 50 xValues = np.arange(minX, maxX + step, step) yValues = self.protocol.evalFunction(xValues) plotter = EmPlotter(style='seaborn-whitegrid') varNameX = self.protocol.labelX.get() varNameY = self.protocol.labelY.get() ax = plotter.createSubPlot( "Regression Plot", "%s [%s]" % (varNameX, strUnit( self.protocol.experiment.variables[varNameX].units.unit)), "%s [%s]" % (varNameY, strUnit( self.protocol.experiment.variables[varNameY].units.unit))) ax.plot(xValues, yValues) ax.plot(X, Y, 'o') return [plotter] else: return [ self.errorMessage("Result file '%s' not produced yet. " % fnResults) ]
def prepareForSampleAnalysis(self, sampleName): sample = self.experiment.samples[sampleName] sampleFit = self.eliminationFitting.getSampleFit(sampleName) sample.interpretDose() self.model.D = sample.getDoseAt(0.0) self.model.Dunits = sample.getDoseUnits() if sampleFit == None: print( " Cannot process %s because its elimination rate cannot be found\n\n" % sampleName) return False self.model.C0 = sampleFit.parameters[0] self.model.C0units = self.eliminationFitting.modelParameterUnits[0] self.model.Ke = sampleFit.parameters[1] self.model.KeUnits = self.eliminationFitting.modelParameterUnits[1] print("Concentration at t=0 = %f [%s]" % (self.model.C0, strUnit(self.model.C0units))) print("Elimination rate = %f [%s]" % (self.model.Ke, strUnit(self.model.KeUnits))) self.experiment.addParameterToSample( sampleName, "Ke", self.model.KeUnits, "Automatically estimated elimination rate", self.model.Ke) return True
def analyzeSample(self, sample, t, C): t = np.insert(t, 0, 0.0) C = np.insert(C, 0, 0.0) if sample.descriptors is None: sample.descriptors = {} self.AUC0t = 0 self.AUMC0t = 0 t0 = t[0] tperiod0 = 0 # Time at which the dose was given T0 = 0 TF = np.max(t) if self.t0.get() != "" and self.tF.get() != "": T0 = float(self.t0.get()) TF = float(self.tF.get()) for idx in range(0, t.shape[0] - 1): if t[idx] >= T0 and t[idx] <= TF: dt = (t[idx + 1] - t[idx]) if C[idx + 1] >= C[idx]: # Trapezoidal in the raise self.AUC0t += 0.5 * dt * (C[idx] + C[idx + 1]) self.AUMC0t += 0.5 * dt * (C[idx] * t[idx] + C[idx + 1] * t[idx + 1]) else: # Log-trapezoidal in the decay if C[idx + 1] > 0 and C[idx] > 0: decrement = C[idx] / C[idx + 1] K = math.log(decrement) B = K / dt self.AUC0t += dt * (C[idx] - C[idx + 1]) / K self.AUMC0t += (C[idx] * (t[idx] - tperiod0) - C[idx + 1] * (t[idx + 1] - tperiod0)) / B - ( C[idx + 1] - C[idx]) / (B * B) if idx == 0: self.Cmax = C[idx] self.Tmax = t[idx] - t0 else: if C[idx] > self.Cmax: self.Cmax = C[idx] self.Tmax = t[idx] - t0 self.MRT = self.AUMC0t / self.AUC0t print(" Cmax=%f [%s]" % (self.Cmax, strUnit(self.Cunits.unit))) print(" Tmax=%f [%s]" % (self.Tmax, strUnit(self.tunits))) print(" AUC0t=%f [%s]" % (self.AUC0t, strUnit(self.AUCunits))) print(" AUMC0t=%f [%s]" % (self.AUMC0t, strUnit(self.AUMCunits))) print(" MRT=%f [%s]" % (self.MRT, strUnit(self.tunits))) print("") sample.descriptors["Tmax"] = self.Tmax sample.descriptors["Cmax"] = self.Cmax sample.descriptors["MRT"] = self.MRT sample.descriptors["AUC0t"] = self.AUC0t sample.descriptors["AUMC0t"] = self.AUMC0t
def postSampleAnalysis(self, sampleName): xunits = self.experiment.getVarUnits(self.varNameX) Cunits = self.experiment.getVarUnits(self.varNameY) Ka = self.model.parameters[0] Ke = self.model.Ke tmax = math.log(Ka / Ke) / (Ka - Ke) self.experiment.addParameterToSample( sampleName, "tmax", xunits, "Estimated time of the Maximum of the non-iv peak", tmax) Cmax = self.model.forwardModel(self.model.parameters, x=[np.atleast_1d(np.array(tmax))])[0][0] self.experiment.addParameterToSample( sampleName, "Cmax", Cunits, "Estimated concentration of the Maximum of the non-iv peak", Cmax) print("tmax = %f [%s]" % (tmax, strUnit(xunits))) print("Cmax = %f [%s]" % (Cmax, strUnit(Cunits)))
def runStatistcs(self, objId): experiment = self.readExperiment(self.inputExperiment.get().fnPKPD) self.printSection("Calculating statistical descriptors") fnStatistics = self._getPath("statistics.txt") fhOut = open(fnStatistics, 'w') for varName, variable in experiment.variables.items(): if variable.role == PKPDVariable.ROLE_LABEL: varValues = experiment.getSubGroupLabels("True", varName) if variable.varType == PKPDVariable.TYPE_TEXT: self.doublePrint(fhOut, "%s ------------" % varName) counter = {} for value in varValues: if value in counter: counter[value] += 1 else: counter[value] = 1 for value in counter: self.doublePrint( fhOut, "Value=%s Total count=%d (%f%%)" % (value, counter[value], 100 * float(counter[value]) / len(varValues))) elif variable.varType == PKPDVariable.TYPE_NUMERIC: self.doublePrint( fhOut, "%s [%s] ------------" % (varName, strUnit(variable.units.unit))) varValues = np.asarray(varValues, np.double) self.doublePrint( fhOut, "Number of observations= %d" % len(varValues)) self.doublePrint( fhOut, "Range= [%f,%f]" % (np.min(varValues), np.max(varValues))) self.doublePrint(fhOut, "Mean= %f" % np.mean(varValues)) self.doublePrint(fhOut, "StdDev= %f" % np.std(varValues)) self.doublePrint( fhOut, "Skewness= %f" % scipy.stats.skew(varValues)) self.doublePrint( fhOut, "Kurtosis= %f" % scipy.stats.kurtosis(varValues)) self.doublePrint( fhOut, "Quantile 5%%= %f" % np.percentile(varValues, 5)) self.doublePrint( fhOut, "Quantile 25%%= %f" % np.percentile(varValues, 25)) self.doublePrint( fhOut, "Quantile 50%%= %f" % np.percentile(varValues, 50)) self.doublePrint( fhOut, "Quantile 75%%= %f" % np.percentile(varValues, 75)) self.doublePrint( fhOut, "Quantile 95%%= %f" % np.percentile(varValues, 95)) self.doublePrint(fhOut, " ") fhOut.close()
def NCA(self, t, C): self.AUC0t = 0 self.AUMC0t = 0 t0 = t[0] tperiod0 = 0 # Time at which the dose was given T0 = 0 TF = np.max(t) if self.NCAt0.get() != "" and self.NCAtF.get() != "": T0 = float(self.NCAt0.get()) TF = float(self.NCAtF.get()) if self.timeUnits == PKPDUnit.UNIT_TIME_MIN: T0 *= 60 TF *= 60 for idx in range(0, t.shape[0] - 1): if t[idx] >= T0 and t[idx] <= TF: dt = (t[idx + 1] - t[idx]) if C[idx + 1] >= C[idx]: # Trapezoidal in the raise self.AUC0t += 0.5 * dt * (C[idx] + C[idx + 1]) self.AUMC0t += 0.5 * dt * (C[idx] * t[idx] + C[idx + 1] * t[idx + 1]) else: # Log-trapezoidal in the decay decrement = C[idx] / C[idx + 1] K = math.log(decrement) B = K / dt self.AUC0t += dt * (C[idx] - C[idx + 1]) / K self.AUMC0t += (C[idx] * (t[idx] - tperiod0) - C[idx + 1] * (t[idx + 1] - tperiod0)) / B - ( C[idx + 1] - C[idx]) / (B * B) if idx == 0: self.Cmax = C[idx] self.Tmax = t[idx] - t0 else: if C[idx] > self.Cmax: self.Cmax = C[idx] self.Tmax = t[idx] - t0 self.MRT = self.AUMC0t / self.AUC0t print(" Cmax=%f [%s]" % (self.Cmax, strUnit(self.Cunits.unit))) print(" Tmax=%f [%s]" % (self.Tmax, strUnit(self.timeUnits))) print(" AUC0t=%f [%s]" % (self.AUC0t, strUnit(self.AUCunits))) print(" AUMC0t=%f [%s]" % (self.AUMC0t, strUnit(self.AUMCunits))) print(" MRT=%f [%s]" % (self.MRT, strUnit(self.timeUnits)))
def _validate(self): errors = [] experiment = self.readExperiment(self.inputExperiment.get().fnPKPD, False) if not self.labelToChange.get() in experiment.variables: errors.append("Cannot find %s as variable" % self.labelToChange) else: variable = experiment.variables[self.labelToChange.get()] if variable.varType != PKPDVariable.TYPE_NUMERIC: errors.append("%s is not a numeric variable" % variable.varName) else: currentUnit = experiment.getVarUnits(self.labelToChange.get()) newUnit = unitFromString(self._getNewUnit()) try: K = convertUnits(1, currentUnit, newUnit) if K == None: errors.append("Unknown conversion from %s to %s. If it makes sense and it is not implemented you may contact [email protected]"%\ (strUnit(currentUnit),strUnit(newUnit))) except: errors.append( "Unknown conversion from %s to %s. If it makes sense and it is not implemented you may contact [email protected]" % (currentUnit, newUnit)) return errors
def _createSlidersFrame(self, content): frame = tk.Frame(content, bg='white') lfBounds = tk.LabelFrame(frame, text="Parameter Bounds", bg='white') gui.configureWeigths(frame) i = 0 self.sliders = {} paramUnits = self.targetProtocol.parameterUnits for paramName, bounds in self.targetProtocol.getParameterBounds().items(): bounds = bounds or (0, 1) slider = MinMaxSlider(lfBounds, "%s [%s]"%(paramName,strUnit(paramUnits[i])), bounds[0], bounds[1], callback=self._onVarChanged) slider.grid(row=i, column=0, padx=5, pady=5) self.sliders[paramName] = slider i += 1 lfBounds.grid(row=0, column=0, sticky='news', padx=5, pady=5) frame.grid(row=0, column=1, sticky='news', padx=5, pady=5)
def runAnalysis(self, objId, xvarName): self.outputExperiment = self.readExperiment( self.inputExperiment.get().fnPKPD) tvarName = None for varName in self.outputExperiment.variables: if self.outputExperiment.variables[ varName].role == PKPDVariable.ROLE_TIME: tvarName = varName break if tvarName is None: raise Exception("Cannot find a time variable in this experiment") tvar = PKPDVariable() tvar.varName = "t" tvar.varType = PKPDVariable.TYPE_NUMERIC tvar.role = PKPDVariable.ROLE_TIME self.tunits = self.outputExperiment.getTimeUnits().unit tvar.units = createUnit(self.tunits) self.Cunits = self.outputExperiment.variables[xvarName].units self.AUCunits = multiplyUnits(tvar.units.unit, self.Cunits.unit) self.AUMCunits = multiplyUnits(tvar.units.unit, self.AUCunits) AUCvar = PKPDVariable() AUCvar.varName = "AUC0t" AUCvar.varType = PKPDVariable.TYPE_NUMERIC AUCvar.role = PKPDVariable.ROLE_LABEL AUCvar.units = createUnit(strUnit(self.AUCunits)) AUMCvar = PKPDVariable() AUMCvar.varName = "AUMC0t" AUMCvar.varType = PKPDVariable.TYPE_NUMERIC AUMCvar.role = PKPDVariable.ROLE_LABEL AUMCvar.units = createUnit(strUnit(self.AUMCunits)) MRTvar = PKPDVariable() MRTvar.varName = "MRT" MRTvar.varType = PKPDVariable.TYPE_NUMERIC MRTvar.role = PKPDVariable.ROLE_LABEL MRTvar.units = createUnit(self.outputExperiment.getTimeUnits().unit) Cmaxvar = PKPDVariable() Cmaxvar.varName = "Cmax" Cmaxvar.varType = PKPDVariable.TYPE_NUMERIC Cmaxvar.role = PKPDVariable.ROLE_LABEL Cmaxvar.units = createUnit(strUnit(self.Cunits.unit)) Tmaxvar = PKPDVariable() Tmaxvar.varName = "Tmax" Tmaxvar.varType = PKPDVariable.TYPE_NUMERIC Tmaxvar.role = PKPDVariable.ROLE_LABEL Tmaxvar.units = createUnit(self.outputExperiment.getTimeUnits().unit) self.outputExperiment.variables["AUC0t"] = AUCvar self.outputExperiment.variables["AUMC0t"] = AUMCvar self.outputExperiment.variables["MRT"] = MRTvar self.outputExperiment.variables["Cmax"] = Cmaxvar self.outputExperiment.variables["Tmax"] = Tmaxvar inputN = len(self.outputExperiment.samples) AUCarray = np.zeros(inputN) AUMCarray = np.zeros(inputN) MRTarray = np.zeros(inputN) CmaxArray = np.zeros(inputN) TmaxArray = np.zeros(inputN) i = 0 for sampleName, sample in self.outputExperiment.samples.items(): [t, Cp] = sample.getXYValues(tvarName, xvarName) print("Analyzing %s" % sampleName) self.analyzeSample(sample, t[0], Cp[0]) AUCarray[i] = self.AUC0t AUMCarray[i] = self.AUMC0t MRTarray[i] = self.MRT CmaxArray[i] = self.Cmax TmaxArray[i] = self.Tmax i += 1 # Report NCA statistics alpha_2 = (100 - 95) / 2 limits = np.percentile(AUCarray, [alpha_2, 100 - alpha_2]) fhSummary = open(self._getPath("summary.txt"), "w") self.doublePrint( fhSummary, "AUC %f%% confidence interval=[%f,%f] [%s] mean=%f" % (95, limits[0], limits[1], strUnit( self.AUCunits), np.mean(AUCarray))) limits = np.percentile(AUMCarray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "AUMC %f%% confidence interval=[%f,%f] [%s] mean=%f" % (95, limits[0], limits[1], strUnit( self.AUMCunits), np.mean(AUMCarray))) limits = np.percentile(MRTarray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "MRT %f%% confidence interval=[%f,%f] [min] mean=%f" % (95, limits[0], limits[1], np.mean(MRTarray))) limits = np.percentile(CmaxArray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Cmax %f%% confidence interval=[%f,%f] [%s] mean=%f" % (95, limits[0], limits[1], strUnit( self.Cunits.unit), np.mean(CmaxArray))) limits = np.percentile(TmaxArray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Tmax %f%% confidence interval=[%f,%f] [min] mean=%f" % (95, limits[0], limits[1], np.mean(TmaxArray))) fhSummary.close() self.outputExperiment.write(self._getPath("experiment.pkpd"))
def simulate(self, objId1, objId2, inputDose, inputN): import sys self.getInVitroModels() self.getScaling() self.getPKModels() if not self.usePKExperiment: otherPKExperiment = PKPDExperiment() otherPKExperiment.load(self.inputPKOtherExperiment.get().fnPKPD) self.outputExperiment = PKPDExperiment() tvar = PKPDVariable() tvar.varName = "t" tvar.varType = PKPDVariable.TYPE_NUMERIC tvar.role = PKPDVariable.ROLE_TIME tvar.units = createUnit(self.fittingPK.predictor.units.unit) self.Cunits = self.fittingPK.predicted.units self.AUCunits = multiplyUnits(tvar.units.unit, self.Cunits.unit) self.AUMCunits = multiplyUnits(tvar.units.unit, self.AUCunits) if self.addIndividuals.get(): self.outputExperiment.variables["t"] = tvar self.outputExperiment.variables[ self.fittingPK.predicted.varName] = self.fittingPK.predicted self.outputExperiment.general[ "title"] = "Simulated ODE response from IVIVC dissolution profiles" self.outputExperiment.general[ "comment"] = "Simulated ODE response from IVIVC dissolution profiles" for via, _ in self.pkModel.drugSource.vias: self.outputExperiment.vias[via.viaName] = via for dose in self.pkModel.drugSource.parsedDoseList: self.outputExperiment.doses[dose.doseName] = dose AUCvar = PKPDVariable() AUCvar.varName = "AUC0t" AUCvar.varType = PKPDVariable.TYPE_NUMERIC AUCvar.role = PKPDVariable.ROLE_LABEL AUCvar.units = createUnit(strUnit(self.AUCunits)) AUMCvar = PKPDVariable() AUMCvar.varName = "AUMC0t" AUMCvar.varType = PKPDVariable.TYPE_NUMERIC AUMCvar.role = PKPDVariable.ROLE_LABEL AUMCvar.units = createUnit(strUnit(self.AUMCunits)) MRTvar = PKPDVariable() MRTvar.varName = "MRT" MRTvar.varType = PKPDVariable.TYPE_NUMERIC MRTvar.role = PKPDVariable.ROLE_LABEL MRTvar.units = createUnit( self.outputExperiment.getTimeUnits().unit) Cmaxvar = PKPDVariable() Cmaxvar.varName = "Cmax" Cmaxvar.varType = PKPDVariable.TYPE_NUMERIC Cmaxvar.role = PKPDVariable.ROLE_LABEL Cmaxvar.units = createUnit(strUnit(self.Cunits.unit)) Tmaxvar = PKPDVariable() Tmaxvar.varName = "Tmax" Tmaxvar.varType = PKPDVariable.TYPE_NUMERIC Tmaxvar.role = PKPDVariable.ROLE_LABEL Tmaxvar.units = createUnit( self.outputExperiment.getTimeUnits().unit) self.outputExperiment.variables["AUC0t"] = AUCvar self.outputExperiment.variables["AUMC0t"] = AUMCvar self.outputExperiment.variables["MRT"] = MRTvar self.outputExperiment.variables["Cmax"] = Cmaxvar self.outputExperiment.variables["Tmax"] = Tmaxvar t = np.arange(self.pkModel.t0, self.pkModel.tF, 1) if self.usePKExperiment: NPKFits = len(self.fittingPK.sampleFits) invivoFits = self.fittingPK.sampleFits else: NPKFits = len(otherPKExperiment.samples) invivoFits = [x for x in otherPKExperiment.samples.values()] for sample in invivoFits: sample.parameters = [ float(x) for x in sample.getDescriptorValues( self.fittingPK.modelParameters) ] NDissolFits = len(self.fittingInVitro.sampleFits) if self.allCombinations: inputN = NPKFits * NDissolFits AUCarray = np.zeros(inputN) AUMCarray = np.zeros(inputN) MRTarray = np.zeros(inputN) CmaxArray = np.zeros(inputN) TmaxArray = np.zeros(inputN) for i in range(0, inputN): print("Simulation no. %d ----------------------" % i) # Get a random PK model if self.allCombinations: nfit = int(i / NDissolFits) else: nfit = int(random.uniform(0, NPKFits)) sampleFitVivo = invivoFits[nfit] print("In vivo sample name=", sampleFitVivo.sampleName) if self.pkPopulation: nbootstrap = int( random.uniform(0, sampleFitVivo.parameters.shape[0])) pkPrmAll = sampleFitVivo.parameters[nbootstrap, :] else: pkPrmAll = sampleFitVivo.parameters pkPrm = pkPrmAll[-self.pkNParams:] # Get the last Nparams print("PK parameters: ", pkPrm) tlag = 0 if self.includeTlag.get() and (not self.tlagIdx is None): tlag = pkPrmAll[self.tlagIdx] print("tlag: ", tlag) bioavailability = 1 if not self.bioavailabilityIdx is None: bioavailability = pkPrmAll[self.bioavailabilityIdx] print("bioavailability: ", bioavailability) # Get a dissolution profile if self.allCombinations: nfit = i % NDissolFits else: nfit = int(random.uniform(0, NDissolFits)) sampleFitVitro = self.fittingInVitro.sampleFits[nfit] if self.dissolutionPopulation: nbootstrap = int( random.uniform(0, sampleFitVitro.parameters.shape[0])) dissolutionPrm = sampleFitVitro.parameters[nbootstrap, :] else: dissolutionPrm = sampleFitVitro.parameters print( "Dissolution parameters: ", np.array2string(np.asarray(dissolutionPrm, dtype=np.float64), max_line_width=1000)) sys.stdout.flush() if sampleFitVivo.sampleName in self.allTimeScalings: keyToUse = sampleFitVivo.sampleName elif len(self.allTimeScalings) == 1: keyToUse = list(self.allTimeScalings.keys())[0] else: raise Exception("Cannot find %s in the scaling keys" % sampleFitVivo.sampleName) nfit = int(random.uniform(0, len(self.allTimeScalings[keyToUse]))) tvitroLevy, tvivoLevy = self.allTimeScalings[keyToUse][nfit] tvivoLevyUnique, tvitroLevyUnique = uniqueFloatValues( tvivoLevy, tvitroLevy) BLevy = InterpolatedUnivariateSpline(tvivoLevyUnique, tvitroLevyUnique, k=1) tvitro = np.asarray(BLevy(t), dtype=np.float64) A = np.clip( self.dissolutionModel.forwardModel(dissolutionPrm, tvitro)[0], 0, 100) if self.conversionType.get() == 0: # In vitro-in vivo correlation Adissol, Fabs = self.allResponseScalings[keyToUse][nfit] AdissolUnique, FabsUnique = uniqueFloatValues(Adissol, Fabs) B = InterpolatedUnivariateSpline(AdissolUnique, FabsUnique, k=1) A = np.asarray(B(A), dtype=np.float64) # Set the dissolution profile self.pkModel.drugSource.getVia().viaProfile.setXYValues(t, A) C = self.pkModel.forwardModel( pkPrm, [t])[0] # forwardModel returns a list of arrays if tlag != 0.0: B = interp1d(t, C) C = B(np.clip(t - tlag, 0.0, None)) C[0:int(tlag)] = 0.0 C *= bioavailability self.NCA(t, C) AUCarray[i] = self.AUC0t AUMCarray[i] = self.AUMC0t MRTarray[i] = self.MRT CmaxArray[i] = self.Cmax TmaxArray[i] = self.Tmax if self.addIndividuals: self.addSample( "Simulation_%d" % i, t, C, "%s---%s" % (sampleFitVivo.sampleName, sampleFitVitro.sampleName)) # Report NCA statistics alpha_2 = (100 - 95) / 2 limits = np.percentile(AUCarray, [alpha_2, 100 - alpha_2]) fhSummary = open(self._getPath("summary.txt"), "w") self.doublePrint( fhSummary, "AUC %f%% confidence interval=[%f,%f] [%s] mean=%f" % (95, limits[0], limits[1], strUnit( self.AUCunits), np.mean(AUCarray))) limits = np.percentile(AUMCarray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "AUMC %f%% confidence interval=[%f,%f] [%s] mean=%f" % (95, limits[0], limits[1], strUnit( self.AUMCunits), np.mean(AUMCarray))) limits = np.percentile(MRTarray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "MRT %f%% confidence interval=[%f,%f] [%s] mean=%f" % (95, limits[0], limits[1], strUnit( self.timeUnits), np.mean(MRTarray))) limits = np.percentile(CmaxArray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Cmax %f%% confidence interval=[%f,%f] [%s] mean=%f" % (95, limits[0], limits[1], strUnit( self.Cunits.unit), np.mean(CmaxArray))) limits = np.percentile(TmaxArray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Tmax %f%% confidence interval=[%f,%f] [%s] mean=%f" % (95, limits[0], limits[1], strUnit( self.timeUnits), np.mean(TmaxArray))) fhSummary.close() if self.addIndividuals: self.outputExperiment.write(self._getPath("experiment.pkpd"), writeToExcel=False)
def runSimulate(self, Nsimulations, confidenceInterval, doses): if self.odeSource.get() == self.SRC_ODE: self.protODE = self.inputODE.get() if hasattr(self.protODE, "outputExperiment"): self.experiment = self.readExperiment( self.protODE.outputExperiment.fnPKPD) elif hasattr(self.protODE, "outputExperiment1"): self.experiment = self.readExperiment( self.protODE.outputExperiment1.fnPKPD) else: raise Exception( "Cannot find an outputExperiment in the input ODE") if self.paramsSource.get() == ProtPKPDODESimulate.PRM_POPULATION: self.fitting = self.readFitting( self.inputPopulation.get().fnFitting, cls="PKPDSampleFitBootstrap") elif self.paramsSource.get() == ProtPKPDODESimulate.PRM_FITTING: self.fitting = self.readFitting( self.inputFitting.get().fnFitting) else: # User defined or experiment if hasattr(self.protODE, "outputFitting"): self.fitting = self.readFitting( self.protODE.outputFitting.fnFitting) elif hasattr(self.protODE, "outputFitting1"): self.fitting = self.readFitting( self.protODE.outputFitting1.fnFitting) self.varNameX = self.fitting.predictor.varName if type(self.fitting.predicted) != list: self.varNameY = self.fitting.predicted.varName else: self.varNameY = [var.varName for var in self.fitting.predicted] tunits = self.experiment.getTimeUnits().unit else: self.varNameX = 't' self.varNameY = 'C' self.fitting = None self.experiment = None self.protODE = None tunits = unitFromString(self.timeUnits.get()) # Create drug source self.clearGroupParameters() self.createDrugSource() # Create output object self.outputExperiment = PKPDExperiment() self.outputExperiment.general["title"] = "Simulated ODE response" self.outputExperiment.general["comment"] = "Simulated ODE response" # Create the predictor variable tvar = PKPDVariable() tvar.varName = "t" tvar.varType = PKPDVariable.TYPE_NUMERIC tvar.role = PKPDVariable.ROLE_TIME tvar.units = createUnit(tunits) self.outputExperiment.variables[self.varNameX] = tvar # Vias if self.odeSource.get() == self.SRC_ODE: self.outputExperiment.vias = self.experiment.vias else: # "[ViaName]; [ViaType]; [tlag]; [bioavailability]" viaPrmList = [ token for token in self.viaPrm.get().strip().split(',') ] if self.viaType.get() == self.VIATYPE_IV: tokens = [ "Intravenous", "iv", "tlag=0 min", "bioavailability=1" ] elif self.viaType.get() == self.VIATYPE_EV0: tokens = ["Oral", "ev0"] + [ "tlag=" + viaPrmList[-2].strip() + " " + self.timeUnits.get() ] + ["bioavailability=" + viaPrmList[-1].strip()] elif self.viaType.get() == self.VIATYPE_EV1: tokens = ["Oral", "ev1"] + [ "tlag=" + viaPrmList[-2].strip() + " " + self.timeUnits.get() ] + ["bioavailability=" + viaPrmList[-1].strip()] vianame = tokens[0] self.outputExperiment.vias[vianame] = PKPDVia( ptrExperiment=self.outputExperiment) self.outputExperiment.vias[vianame].parseTokens(tokens) # Read the doses dunits = PKPDUnit.UNIT_NONE for line in self.doses.get().replace('\n', ';;').split(';;'): tokens = line.split(';') if len(tokens) < 5: print("Skipping dose: ", line) continue dosename = tokens[0].strip() self.outputExperiment.doses[dosename] = PKPDDose() self.outputExperiment.doses[dosename].parseTokens( tokens, self.outputExperiment.vias) dunits = self.outputExperiment.doses[dosename].getDoseUnits() # Create predicted variables if self.odeSource.get() == self.SRC_ODE: if type(self.fitting.predicted) != list: self.outputExperiment.variables[ self.varNameY] = self.experiment.variables[self.varNameY] else: for varName in self.varNameY: self.outputExperiment.variables[ varName] = self.experiment.variables[varName] else: Cvar = PKPDVariable() Cvar.varName = "C" Cvar.varType = PKPDVariable.TYPE_NUMERIC Cvar.role = PKPDVariable.ROLE_MEASUREMENT Cvar.units = createUnit( divideUnits(dunits.unit, unitFromString(self.volumeUnits.get()))) self.outputExperiment.variables[self.varNameY] = Cvar # Setup model if self.odeSource.get() == self.SRC_ODE: self.model = self.protODE.createModel() if hasattr(self.protODE, "deltaT"): self.model.deltaT = self.protODE.deltaT.get() else: if self.pkType.get() == self.PKTYPE_COMP1: self.model = PK_Monocompartment() elif self.pkType.get() == self.PKTYPE_COMP2: self.model = PK_Twocompartment() elif self.pkType.get() == self.PKTYPE_COMP2CLCLINT: self.model = PK_TwocompartmentsClintCl() self.model.setExperiment(self.outputExperiment) self.model.setXVar(self.varNameX) self.model.setYVar(self.varNameY) Nsamples = int( math.ceil((self.tF.get() - self.t0.get()) / self.model.deltaT)) + 1 self.model.x = [ self.t0.get() + i * self.model.deltaT for i in range(0, Nsamples) ] self.modelList.append(self.model) auxSample = PKPDSample() auxSample.descriptors = {} auxSample.doseDictPtr = self.outputExperiment.doses auxSample.variableDictPtr = self.outputExperiment.variables auxSample.doseList = self.outputExperiment.doses.keys() auxSample.interpretDose() self.drugSource.setDoses(auxSample.parsedDoseList, self.t0.get() - 10, self.tF.get() + 10) self.model.drugSource = self.drugSource # Check units # Dunits = self.outputExperiment.doses[dosename].dunits # Cunits = self.experiment.variables[self.varNameY].units # Process user parameters if self.odeSource.get() == self.SRC_ODE: if self.paramsSource == ProtPKPDODESimulate.PRM_POPULATION: Nsimulations = self.Nsimulations.get() elif self.paramsSource == ProtPKPDODESimulate.PRM_USER_DEFINED: lines = self.prmUser.get().strip().replace('\n', ';;').split(';;') Nsimulations = len(lines) prmUser = [] for line in lines: tokens = line.strip().split(',') prmUser.append([float(token) for token in tokens]) elif self.paramsSource == ProtPKPDODESimulate.PRM_FITTING: Nsimulations = len(self.fitting.sampleFits) else: self.inputExperiment = self.readExperiment( self.inputExperiment.get().fnPKPD) Nsimulations = len(self.inputExperiment.samples) inputSampleNames = self.inputExperiment.samples.keys() else: lines = self.prmUser.get().strip().replace('\n', ';;').split(';;') Nsimulations = len(lines) prmUser = [] for line in lines: tokens = line.strip().split(',') prmUser.append([float(token) for token in tokens]) # Simulate the different responses simulationsX = self.model.x simulationsY = np.zeros( (Nsimulations, len(simulationsX), self.getResponseDimension())) AUCarray = np.zeros(Nsimulations) AUMCarray = np.zeros(Nsimulations) MRTarray = np.zeros(Nsimulations) CminArray = np.zeros(Nsimulations) CmaxArray = np.zeros(Nsimulations) CavgArray = np.zeros(Nsimulations) CtauArray = np.zeros(Nsimulations) TminArray = np.zeros(Nsimulations) TmaxArray = np.zeros(Nsimulations) TtauArray = np.zeros(Nsimulations) fluctuationArray = np.zeros(Nsimulations) percentageAccumulationArray = np.zeros(Nsimulations) wb = openpyxl.Workbook() wb.active.title = "Simulations" for i in range(0, Nsimulations): self.setTimeRange(None) if self.odeSource.get() == self.SRC_ODE: if self.paramsSource == ProtPKPDODESimulate.PRM_POPULATION: # Take parameters randomly from the population nfit = int(random.uniform(0, len(self.fitting.sampleFits))) sampleFit = self.fitting.sampleFits[nfit] nprm = int(random.uniform(0, sampleFit.parameters.shape[0])) parameters = sampleFit.parameters[nprm, :] self.fromSample = "Population %d" % nprm elif self.paramsSource == ProtPKPDODESimulate.PRM_USER_DEFINED: parameters = np.asarray(prmUser[i], np.double) self.fromSample = "User defined" elif self.paramsSource == ProtPKPDODESimulate.PRM_FITTING: parameters = self.fitting.sampleFits[i].parameters self.fromSample = self.fitting.sampleFits[i].sampleName else: parameters = [] self.fromSample = inputSampleNames[i] sample = self.inputExperiment.samples[self.fromSample] for prmName in self.fitting.modelParameters: parameters.append( float(sample.getDescriptorValue(prmName))) else: parameters = np.asarray(viaPrmList[:-2] + prmUser[i], np.double) self.fromSample = "User defined" print("From sample name: %s" % self.fromSample) print("Simulated sample %d: %s" % (i, str(parameters))) # Prepare source and this object self.drugSource.setDoses(auxSample.parsedDoseList, self.model.t0, self.model.tF) if self.protODE is not None: self.protODE.configureSource(self.drugSource) self.model.drugSource = self.drugSource parameterNames = self.getParameterNames( ) # Necessary to count the number of source and PK parameters # Prepare the model self.setParameters(parameters) y = self.forwardModel(parameters, [simulationsX] * self.getResponseDimension()) # Create AUC, AUMC, MRT variables and units if i == 0: if type(self.varNameY) != list: self.Cunits = self.outputExperiment.variables[ self.varNameY].units else: self.Cunits = self.outputExperiment.variables[ self.varNameY[0]].units self.AUCunits = multiplyUnits(tvar.units.unit, self.Cunits.unit) self.AUMCunits = multiplyUnits(tvar.units.unit, self.AUCunits) if self.addStats or self.addIndividuals: fromvar = PKPDVariable() fromvar.varName = "FromSample" fromvar.varType = PKPDVariable.TYPE_TEXT fromvar.role = PKPDVariable.ROLE_LABEL fromvar.units = createUnit("none") AUCvar = PKPDVariable() AUCvar.varName = "AUC0t" AUCvar.varType = PKPDVariable.TYPE_NUMERIC AUCvar.role = PKPDVariable.ROLE_LABEL AUCvar.units = createUnit(strUnit(self.AUCunits)) AUMCvar = PKPDVariable() AUMCvar.varName = "AUMC0t" AUMCvar.varType = PKPDVariable.TYPE_NUMERIC AUMCvar.role = PKPDVariable.ROLE_LABEL AUMCvar.units = createUnit(strUnit(self.AUMCunits)) MRTvar = PKPDVariable() MRTvar.varName = "MRT" MRTvar.varType = PKPDVariable.TYPE_NUMERIC MRTvar.role = PKPDVariable.ROLE_LABEL MRTvar.units = createUnit( self.outputExperiment.getTimeUnits().unit) Cmaxvar = PKPDVariable() Cmaxvar.varName = "Cmax" Cmaxvar.varType = PKPDVariable.TYPE_NUMERIC Cmaxvar.role = PKPDVariable.ROLE_LABEL Cmaxvar.units = createUnit(strUnit(self.Cunits.unit)) Tmaxvar = PKPDVariable() Tmaxvar.varName = "Tmax" Tmaxvar.varType = PKPDVariable.TYPE_NUMERIC Tmaxvar.role = PKPDVariable.ROLE_LABEL Tmaxvar.units = createUnit( self.outputExperiment.getTimeUnits().unit) Cminvar = PKPDVariable() Cminvar.varName = "Cmin" Cminvar.varType = PKPDVariable.TYPE_NUMERIC Cminvar.role = PKPDVariable.ROLE_LABEL Cminvar.units = createUnit(strUnit(self.Cunits.unit)) Tminvar = PKPDVariable() Tminvar.varName = "Tmin" Tminvar.varType = PKPDVariable.TYPE_NUMERIC Tminvar.role = PKPDVariable.ROLE_LABEL Tminvar.units = createUnit( self.outputExperiment.getTimeUnits().unit) Cavgvar = PKPDVariable() Cavgvar.varName = "Cavg" Cavgvar.varType = PKPDVariable.TYPE_NUMERIC Cavgvar.role = PKPDVariable.ROLE_LABEL Cavgvar.units = createUnit(strUnit(self.Cunits.unit)) self.outputExperiment.variables["FromSample"] = fromvar self.outputExperiment.variables["AUC0t"] = AUCvar self.outputExperiment.variables["AUMC0t"] = AUMCvar self.outputExperiment.variables["MRT"] = MRTvar self.outputExperiment.variables["Cmax"] = Cmaxvar self.outputExperiment.variables["Tmax"] = Tmaxvar self.outputExperiment.variables["Cmin"] = Cminvar self.outputExperiment.variables["Tmin"] = Tminvar self.outputExperiment.variables["Cavg"] = Cavgvar excelWriteRow([ "simulationName", "fromSample", "doseNumber", "AUC [%s]" % strUnit(self.AUCunits), "AUMC [%s]" % strUnit(self.AUMCunits), "Cmin [%s]" % strUnit(self.Cunits.unit), "Cavg [%s]" % strUnit(self.Cunits.unit), "Cmax [%s]" % strUnit(self.Cunits.unit), "Ctau [%s]" % strUnit(self.Cunits.unit), "Tmin [%s]" % strUnit(self.outputExperiment.getTimeUnits().unit), "Tmax [%s]" % strUnit(self.outputExperiment.getTimeUnits().unit), "Ttau [%s]" % strUnit(self.outputExperiment.getTimeUnits().unit) ], wb, 1, bold=True) wbRow = 2 # Evaluate AUC, AUMC and MRT in the last full period AUClist, AUMClist, Cminlist, Cavglist, Cmaxlist, Ctaulist, Tmaxlist, Tminlist, Ttaulist = self.NCA( self.model.x, y[0]) for doseNo in range(0, len(AUClist)): excelWriteRow([ "Simulation_%d" % i, self.fromSample, doseNo, AUClist[doseNo], AUMClist[doseNo], Cminlist[doseNo], Cavglist[doseNo], Cmaxlist[doseNo], Ctaulist[doseNo], Tminlist[doseNo], Tmaxlist[doseNo], Ttaulist[doseNo] ], wb, wbRow) wbRow += 1 # Keep results for j in range(self.getResponseDimension()): simulationsY[i, :, j] = y[j] AUCarray[i] = self.AUC0t AUMCarray[i] = self.AUMC0t MRTarray[i] = self.MRT CminArray[i] = self.Cmin CmaxArray[i] = self.Cmax CavgArray[i] = self.Cavg CtauArray[i] = self.Ctau TminArray[i] = self.Tmin TmaxArray[i] = self.Tmax TtauArray[i] = self.Ttau fluctuationArray[i] = self.fluctuation percentageAccumulationArray[i] = self.percentageAccumulation if self.addIndividuals or self.paramsSource != ProtPKPDODESimulate.PRM_POPULATION: self.addSample("Simulation_%d" % i, dosename, simulationsX, y[0]) # Report NCA statistics fhSummary = open(self._getPath("summary.txt"), "w") alpha_2 = (100 - self.confidenceLevel.get()) / 2 limits = np.percentile(AUCarray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "AUC %f%% confidence interval=[%f,%f] [%s] mean=%f" % (self.confidenceLevel.get(), limits[0], limits[1], strUnit(self.AUCunits), np.mean(AUCarray))) limits = np.percentile(AUMCarray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "AUMC %f%% confidence interval=[%f,%f] [%s] mean=%f" % (self.confidenceLevel.get(), limits[0], limits[1], strUnit(self.AUMCunits), np.mean(AUMCarray))) limits = np.percentile(MRTarray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "MRT %f%% confidence interval=[%f,%f] [%s] mean=%f" % (self.confidenceLevel.get(), limits[0], limits[1], strUnit(self.outputExperiment.getTimeUnits().unit), np.mean(MRTarray))) limits = np.percentile(CminArray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Cmin %f%% confidence interval=[%f,%f] [%s] mean=%f" % (self.confidenceLevel.get(), limits[0], limits[1], strUnit(self.Cunits.unit), np.mean(CminArray))) limits = np.percentile(CmaxArray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Cmax %f%% confidence interval=[%f,%f] [%s] mean=%f" % (self.confidenceLevel.get(), limits[0], limits[1], strUnit(self.Cunits.unit), np.mean(CmaxArray))) limits = np.percentile(CavgArray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Cavg %f%% confidence interval=[%f,%f] [%s] mean=%f" % (self.confidenceLevel.get(), limits[0], limits[1], strUnit(self.Cunits.unit), np.mean(CavgArray))) limits = np.percentile(CtauArray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Ctau %f%% confidence interval=[%f,%f] [%s] mean=%f" % (self.confidenceLevel.get(), limits[0], limits[1], strUnit(self.Cunits.unit), np.mean(CtauArray))) limits = np.percentile(TminArray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Tmin %f%% confidence interval=[%f,%f] [%s] mean=%f" % (self.confidenceLevel.get(), limits[0], limits[1], strUnit(self.outputExperiment.getTimeUnits().unit), np.mean(TminArray))) limits = np.percentile(TmaxArray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Tmax %f%% confidence interval=[%f,%f] [%s] mean=%f" % (self.confidenceLevel.get(), limits[0], limits[1], strUnit(self.outputExperiment.getTimeUnits().unit), np.mean(TmaxArray))) limits = np.percentile(TtauArray, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Ttau %f%% confidence interval=[%f,%f] [%s] mean=%f" % (self.confidenceLevel.get(), limits[0], limits[1], strUnit(self.outputExperiment.getTimeUnits().unit), np.mean(TtauArray))) aux = fluctuationArray[~np.isnan(fluctuationArray)] if len(aux) > 0: limits = np.percentile(aux, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Fluctuation %f%% confidence interval=[%f,%f] [%%] mean=%f" % (self.confidenceLevel.get(), limits[0] * 100, limits[1] * 100, np.mean(aux) * 100)) aux = percentageAccumulationArray[~np.isnan(percentageAccumulationArray )] limits = np.percentile(aux, [alpha_2, 100 - alpha_2]) self.doublePrint( fhSummary, "Accum(1) %f%% confidence interval=[%f,%f] [%%] mean=%f" % (self.confidenceLevel.get(), limits[0] * 100, limits[1] * 100, np.mean(aux) * 100)) fhSummary.close() # Calculate statistics if self.addStats and self.odeSource == 0 and self.paramsSource == 0: if self.paramsSource != ProtPKPDODESimulate.PRM_USER_DEFINED: limits = np.percentile(simulationsY, [alpha_2, 100 - alpha_2], axis=0) print("Lower limit NCA") self.NCA(simulationsX, limits[0]) self.fromSample = "LowerLimit" self.addSample("LowerLimit", dosename, simulationsX, limits[0]) print("Mean profile NCA") if self.getResponseDimension() == 1: mu = np.mean(simulationsY, axis=0) self.NCA(simulationsX, mu) else: mu = [] for j in range(self.getResponseDimension()): mu.append(np.mean(simulationsY[:, :, j], axis=0)) self.NCA(simulationsX, mu[0]) self.fromSample = "Mean" self.addSample("Mean", dosename, simulationsX, mu) if self.paramsSource != ProtPKPDODESimulate.PRM_USER_DEFINED: print("Upper limit NCA") self.NCA(simulationsX, limits[1]) self.fromSample = "UpperLimit" self.addSample("UpperLimit", dosename, simulationsX, limits[1]) self.outputExperiment.write(self._getPath("experiment.pkpd")) wb.save(self._getPath("nca.xlsx"))
def NCA(self, t, C): AUClist = [] AUMClist = [] Cminlist = [] Cavglist = [] Cmaxlist = [] Ctaulist = [] Tmaxlist = [] Tminlist = [] Ttaulist = [] Ndoses = len(self.drugSource.parsedDoseList) for ndose in range(0, max(Ndoses, 1)): tperiod0 = self.drugSource.parsedDoseList[ndose].t0 if ndose + 1 < Ndoses: tperiodF = self.drugSource.parsedDoseList[ ndose + 1].t0 - self.model.deltaT else: tperiodF = np.max(t) - 1 idx0 = find_nearest(t, tperiod0) idxF = find_nearest(t, tperiodF) if idxF >= len(t) - 1: idxF = len(t) - 2 AUC0t = 0 AUMC0t = 0 t0 = t[idx0 + 1] for idx in range(idx0, idxF + 1): dt = (t[idx + 1] - t[idx]) if C[idx + 1] >= C[idx]: # Trapezoidal in the raise AUC0t += 0.5 * dt * (C[idx] + C[idx + 1]) AUMC0t += 0.5 * dt * (C[idx] * t[idx] + C[idx + 1] * t[idx + 1]) else: # Log-trapezoidal in the decay decrement = C[idx] / C[idx + 1] K = math.log(decrement) B = K / dt AUC0t += dt * (C[idx] - C[idx + 1]) / K AUMC0t += (C[idx] * (t[idx] - tperiod0) - C[idx + 1] * (t[idx + 1] - tperiod0)) / B - ( C[idx + 1] - C[idx]) / (B * B) if idx == idx0: Cmax = C[idx] Tmax = t[idx] - t0 Cmin = C[idx] Tmin = t[idx] - t0 else: if C[idx] < Cmin: Cmin = C[idx] Tmin = t[idx] - t0 elif C[idx] > Cmax: Cmax = C[idx] Tmax = t[idx] - t0 # if ndose==0: # Cmin=C[idx] # Tmin=t[idx]-t0 AUClist.append(AUC0t) AUMClist.append(AUMC0t) Cminlist.append(Cmin) Cmaxlist.append(Cmax) Ctaulist.append(C[idxF]) Ttaulist.append(t[idxF] - t0) Tmaxlist.append(Tmax) Tminlist.append(Tmin) Cavglist.append(AUC0t / (t[idxF] - t[idx0])) print("Fluctuation = Cmax/Cmin") print("Accumulation(1) = Cavg(n)/Cavg(1) %") print("Accumulation(n) = Cavg(n)/Cavg(n-1) %") print("Steady state fraction(n) = Cavg(n)/Cavg(last) %") for ndose in range(0, len(AUClist)): if Cminlist[ndose] != 0: fluctuation = Cmaxlist[ndose] / Cminlist[ndose] else: fluctuation = np.nan if ndose > 0: accumn = Cavglist[ndose] / Cavglist[ndose - 1] else: accumn = 0 print("Dose #%d t=[%f,%f]: Cavg= %f [%s] Cmin= %f [%s] Tmin= %d [%s] Cmax= %f [%s] Tmax= %d [%s] Ctau= %f [%s] Ttau= %d [%s] Fluct= %f %% Accum(1)= %f %% Accum(n)= %f %% SSFrac(n)= %f %% AUC= %f [%s] AUMC= %f [%s]"%\ (ndose+1,t[idx0],t[idxF],Cavglist[ndose], strUnit(self.Cunits.unit), Cminlist[ndose], strUnit(self.Cunits.unit), int(Tminlist[ndose]), strUnit(self.outputExperiment.getTimeUnits().unit), Cmaxlist[ndose], strUnit(self.Cunits.unit), int(Tmaxlist[ndose]), strUnit(self.outputExperiment.getTimeUnits().unit), Ctaulist[ndose], strUnit(self.Cunits.unit), int(Ttaulist[ndose]), strUnit(self.outputExperiment.getTimeUnits().unit), fluctuation*100, Cavglist[ndose]/Cavglist[0]*100, accumn*100, Cavglist[ndose]/Cavglist[-1]*100, AUClist[ndose],strUnit(self.AUCunits), AUMClist[ndose],strUnit(self.AUMCunits))) self.AUC0t = float(AUClist[-1]) self.AUMC0t = float(AUMClist[-1]) self.MRT = self.AUMC0t / self.AUC0t self.Cmin = float(Cminlist[-1]) self.Cmax = float(Cmaxlist[-1]) self.Tmin = float(Tminlist[-1]) self.Tmax = float(Tmaxlist[-1]) self.Cavg = float(Cavglist[-1]) self.Ctau = float(Ctaulist[-1]) self.Ttau = float(Ttaulist[-1]) self.fluctuation = self.Cmax / self.Cmin if self.Cmin > 0 else np.nan self.percentageAccumulation = Cavglist[-1] / Cavglist[0] if Cavglist[ 0] > 0 else np.nan print(" AUC0t=%f [%s]" % (self.AUC0t, strUnit(self.AUCunits))) print(" AUMC0t=%f [%s]" % (self.AUMC0t, strUnit(self.AUMCunits))) print(" MRT=%f [%s]" % (self.MRT, strUnit(self.outputExperiment.getTimeUnits().unit))) print(" Cmax=%f [%s]" % (self.Cmax, strUnit(self.Cunits.unit))) print(" Cmin=%f [%s]" % (self.Cmin, strUnit(self.Cunits.unit))) print(" Cavg=%f [%s]" % (self.Cavg, strUnit(self.Cunits.unit))) print(" Ctau=%f [%s]" % (self.Ctau, strUnit(self.Cunits.unit))) print(" Tmax=%f [%s]" % (self.Tmax, strUnit(self.outputExperiment.getTimeUnits().unit))) print(" Tmin=%f [%s]" % (self.Tmin, strUnit(self.outputExperiment.getTimeUnits().unit))) print(" Ttau=%f [%s]" % (self.Ttau, strUnit(self.outputExperiment.getTimeUnits().unit))) return AUClist, AUMClist, Cminlist, Cavglist, Cmaxlist, Ctaulist, Tmaxlist, Tminlist, Ttaulist