def solve(self, objId1): self.experiment = self.readExperiment(self.inputExperiment.get().fnPKPD) # Create output object self.outputExperiment = None timeRange = self.experiment.getRange(self.timeVar.get()) for sampleName, sample in self.experiment.samples.items(): # Get t, A t=np.asarray(sample.getValues(self.timeVar.get()),dtype=np.float64) A=np.asarray(sample.getValues(self.amountVar.get()),dtype=np.float64) if t[0]>0: t=np.insert(t,0,0) # Add (0,0) to the profile A=np.insert(A,0,0) t, A = uniqueFloatValues(t, A) if self.resampleT.get()>0: B = InterpolatedUnivariateSpline(t, A, k=1) t = np.arange(np.min(t),np.max(t)+self.resampleT.get(),self.resampleT.get()) A = B(t) # Find C and Cp C, Cp = self.calculateConcentrations2(t,A) if self.outputExperiment is None: self.outputExperiment = PKPDExperiment() tvar = PKPDVariable() tvar.varName = "t" tvar.varType = PKPDVariable.TYPE_NUMERIC tvar.role = PKPDVariable.ROLE_TIME tvar.units = createUnit(self.experiment.getTimeUnits().unit) Cvar = PKPDVariable() Cvar.varName = "C" Cvar.varType = PKPDVariable.TYPE_NUMERIC Cvar.role = PKPDVariable.ROLE_MEASUREMENT Lunits = createUnit("L") Cvar.units = createUnit(divideUnits(self.experiment.getVarUnits(self.amountVar.get()),Lunits.unit)) Cvar.comment = "Concentration central compartment" Cpvar = PKPDVariable() Cpvar.varName = "Cp" Cpvar.varType = PKPDVariable.TYPE_NUMERIC Cpvar.role = PKPDVariable.ROLE_MEASUREMENT Cpvar.units = createUnit(divideUnits(self.experiment.getVarUnits(self.amountVar.get()),Lunits.unit)) Cpvar.comment = "Concentration peripheral compartment" self.outputExperiment.variables[tvar.varName] = tvar self.outputExperiment.variables[Cvar.varName] = Cvar self.outputExperiment.variables[Cpvar.varName] = Cpvar self.outputExperiment.general["title"]="Inverse Loo-Riegelman" self.outputExperiment.general["comment"]="" self.addSample(sampleName,t,C,Cp) self.outputExperiment.write(self._getPath("experiment.pkpd"))
def calculateParameterUnits(self, sample): tunits = self.experiment.getVarUnits(self.xName) Cunits = self.experiment.getVarUnits(self.yName) Dunits = sample.getDoseUnits() AUCunits = multiplyUnits(tunits, Cunits) AUMCunits = multiplyUnits(tunits, AUCunits) Vunits = divideUnits(Dunits, Cunits) CLunits = divideUnits(Vunits, tunits) self.parameterUnits = [ AUCunits, AUCunits, AUMCunits, AUMCunits, tunits, Vunits, Vunits, CLunits, CLunits, tunits ]
def calculateParameterUnits(self, sample): yunits = self.experiment.getVarUnits(self.yName) xunits = self.experiment.getVarUnits(self.xName) sunits = divideUnits(yunits, xunits) if self.allowTlag: self.parameterUnits = [xunits, sunits] else: self.parameterUnits = [sunits] return self.parameterUnits
def calculateParameterUnits(self, sample): yunits = self.experiment.getVarUnits(self.yName) xunits = self.experiment.getVarUnits(self.xName) sunits = divideUnits(yunits, xunits) self.parameterUnits = [] for i in range(0, self.N + 1): deg = self.N - i if deg == 0: self.parameterUnits.append(yunits) elif deg == 1: self.parameterUnits.append(sunits) else: self.parameterUnits.append(PKPDUnit.UNIT_NONE) return self.parameterUnits
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"))