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