def obtain_data(self, dataman, dataname, *args):
if dataname == 'basic_vessel_radial':
property_name, vesselgroup, tumorgroup, sample_length, bins_spec, distance_distribution_name, ld, cachelocation = args
def write(gmeasure, groupname):
if property_name == 'mvd':
smpl = dataman.obtain_data('basic_vessel_samples', 'flags', vesselgroup, sample_length)
smpl = np.ones_like(smpl) # only need number of samples
avg_mode = radialAvgPerVolume
elif property_name == 'phi_vessels':
smpl = dataman.obtain_data('basic_vessel_samples', 'radius', vesselgroup, sample_length)
smpl = math.pi*np.power(smpl, 2.) # pi r^2 * length, where length comes in through GenerateRadialDistributions
avg_mode = radialAvgPerVolume
elif property_name in ['S_over_V', 'S_rho']: # alternative names for now ...
smpl = dataman.obtain_data('basic_vessel_samples', 'radius', vesselgroup, sample_length)
smpl = (math.pi*2.)*smpl # 2 pi r = surface area
avg_mode = radialAvgPerVolume
elif property_name == 'radial_distance':
smpl, _, _ , _ = dataman.obtain_data('distancemap_samples', vesselgroup, tumorgroup, sample_length, distance_distribution_name, ld)
avg_mode = radialAvgPerVessels
else:
smpl = dataman.obtain_data('basic_vessel_samples', property_name, vesselgroup, sample_length)
avg_mode = radialAvgPerVessels
a, = GenerateRadialDistributions(dataman, vesselgroup, tumorgroup, sample_length, bins_spec, distance_distribution_name, ld, [(smpl, avg_mode)])
ds = a.write(gmeasure, groupname)
ds.attrs['BINS_SPEC'] = str(bins_spec)
def read(gmeasure, groupname):
assert groupname == property_name
return FixUnits_(groupname, myutils.MeanValueArray.read(gmeasure, groupname))
version = myutils.checksum(MakeVersionId(vesselgroup), MakeVersionId(tumorgroup))
return HdfCacheRadialDistribution((read, write), property_name, bins_spec, distance_distribution_name, cachelocation, version)
def makeCacheLocation(self, dataname, args, name, ver=1):
vesselgroup, tumorgroup, fieldLd, fieldLdFine = args
myfile, mycachelocation = self.cachelocationFactory(
dataname, vesselgroup, tumorgroup,
myutils.checksum(fieldLd.box, fieldLd.scale,
self.fine_bin_subdivision))
version = (None, ) * len(mycachelocation) + (ver, )
mycachelocation = mycachelocation + (name, )
return myfile, mycachelocation, version
def obtain_average_radial_distance(dataman, fmeasure, groups, bins_spec,
distancemap_spec):
l = []
for group in groups:
cachelocation = (fmeasure, '%s_PARAMID%s_FILEID%s' %
(group.name, str(hash(bins_spec)),
myutils.checksum(group.file.filename)))
data = dataman.obtain_data('basic_vessel_radial', 'radial_distance',
group['vessels'], group['tumor'], 30.,
bins_spec, distancemap_spec, None,
cachelocation)
l.append(data)
return myutils.MeanValueArray.fromSummation(x.avg for x in l)
def create_nice_file_containing_all_the_data():
filenames = sys.argv[1:]
files = [h5files.open(fn, 'r') for fn in filenames]
fmeasure = h5files.open('analyzeVesselTumor.h5', 'a')
dataman = myutils.DataManager(10, [DataVesselLength(), DataVesselTumor()])
allgroups = defaultdict(list)
for f in files:
keys = filter(lambda k: k.startswith('out'), f.keys())
for k in keys:
allgroups[k].append(f[k])
allgroups = [(k, allgroups[k]) for k in sorted(allgroups.keys())]
groupslist = [allgroups[-1]]
outfn = 'Length-%s.pdf' % splitext(basename(filenames[0]))[0]
pprint(groupslist)
print '-> %s' % (outfn)
for key, groups in groupslist:
for group in groups:
cachelocation = (fmeasure, '%s_file_%s_FILEID%s' %
(group.name, group.file.filename,
myutils.checksum(group.file.filename)))
data = dataman.obtain_data('length_dist', 'length_dist',
group['vessels'], group['tumor'],
cachelocation)
data = dataman.obtain_data('within_fake_tumor',
'radii_within_tumor', group['vessels'],
group['tumor'], cachelocation)
data = dataman.obtain_data('within_fake_tumor',
'pressures_within_tumor',
group['vessels'], group['tumor'],
cachelocation)
data = dataman.obtain_data('within_fake_tumor',
'flows_within_tumor', group['vessels'],
group['tumor'], cachelocation)
print('you just created a big nice file')
orig = ld.GetOriginPosition()
orig += offset
ld.SetOriginPosition(orig)
parent = g.parent
name = str(g.name)
del g
del parent[name]
#krebsutils.write_lattice_data_to_hdf(parent, name, ld)
fn=str(parent.file.filename)
#path=str(vesselgroup.name)
krebsutils.write_lattice_data_to_hdf_by_filename(fn, name, ld)
return offset
def GenerateSingleCapillaryWPo2(dataman, f, config_name, config_version, (bfparams, po2params, params)):
version = myutils.checksum(1,config_version, params, bfparams, po2params)
def write(gmeasure, name):
gmeasure = gmeasure.create_group(name)
# --- create single capillary vessel system ---
p = params['pgrad']*params['size'][0]*params['scale']
krebsutils.vesselgen_generate_single(gmeasure, params['size'], params['direction_mode'], params['scale'], params['ld_type'], params['r'], 0.1, p, params['size'][0]/10, bfparams)
vesselgroup = gmeasure['vessels']
if params['direction_mode'] == 0:
CenterLattice(vesselgroup['lattice'])
vesselgroup.attrs['VERSION'] = version
# --- setup po2 stuff ---
po2group = gmeasure.create_group('po2')
po2group.attrs['SOURCE_FILE'] = f.filename
po2group.attrs['SOURCE_PATH'] = str(vesselgroup.name)
po2group['SOURCE'] = h5py.SoftLink(vesselgroup)
def cachelocation(g):
path = posixpath.join('FileCS_'+myutils.checksum(basename(g.file.filename)), g.name.strip(posixpath.sep))
return (f_measure, path)
def cachelocationEnsemble(dataname, groups):
groupchecksum = myutils.checksum(*map(
lambda g: str(g.file.filename + '/' + g.name), sum(groups, [])))
path = ('%s_%s' % (dataname, groupchecksum), )
return (f_measure, path)
def obtain_data(self, dataman, dataname, *args):
if dataname == 'detailedPO2Parameters':
po2group, = args
return detailedo2.readParameters(po2group)
if dataname == 'detailedPO2':
po2group, = args
a = np.asarray(po2group['po2vessels'])
if a.shape[0] <> 2: a = np.transpose(a)
po2field = po2group['po2field']
ld = krebsutils.read_lattice_data_from_hdf(po2group['field_ld'])
parameters = dataman.obtain_data('detailedPO2Parameters', po2group)
return a, ld, po2field, parameters
if dataname == 'detailedPO2_consumption':
po2group, tumorgroup = args
return detailedo2.computeO2Uptake(po2group, tumorgroup)
if dataname == 'detailedPO2_samples' or dataname == 'detailedPO2_total_fluxes':
prop, po2group, sample_length, every, cachelocation = args
def read(gmeasure, name):
gmeasure = gmeasure[name]
if dataname == 'detailedPO2_samples':
if prop == 'gtv':
parameters = dataman.obtain_data(
'detailedPO2Parameters', po2group)
#po2 = dataman.obtain_data('detailedPO2_samples','po2', *args[1:])
#extpo2 = dataman.obtain_data('detailedPO2_samples','extpo2', *args[1:])
#return (po2-extpo2)/(parameters['grid_lattice_const']*parameters.get('transvascular_ring_size',0.5))
gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups(
po2group)
jtv = dataman.obtain_data('detailedPO2_samples', 'jtv',
*args[1:])
#radius = dataman.obtain_data('basic_vessel_samples', 'radius', gvessels, sample_length)
#radius = radius * (60.e-4*math.pi*2.* parameters['kD_tissue']*parameters['alpha_t'])
radius = (
60.e-4 *
parameters.get('D_tissue',
parameters.get('kD_tissue', None)) *
parameters.get('solubility_tissue',
parameters.get('alpha_t', None)))
gtv = jtv / radius
return gtv
elif prop == 'sat':
po2 = dataman.obtain_data('detailedPO2_samples', 'po2',
*args[1:])
parameters = dataman.obtain_data(
'detailedPO2Parameters', po2group)
return detailedo2.PO2ToSaturation(po2, parameters)
else:
ds = gmeasure['smpl_' + prop]
ds = ds[...] if every is None else ds[::every]
return ds
else:
keys = filter(lambda k: k.startswith('flux_'),
gmeasure.keys())
fluxes = dict(map(lambda k: (k[5:], gmeasure[k][()]),
keys))
fluxes['e1'] = abs(
100. * (fluxes['Jin_root'] - fluxes['Jout_root'] -
fluxes['Jout_tv']) / fluxes['Jin_root'])
fluxes['e2'] = abs(
100. *
(fluxes['Jin_root'] - fluxes['Jout_root'] -
fluxes['Jout_cons'] - fluxes.get('tv_cons', 0.)) /
fluxes['Jin_root'])
fluxes['e3'] = abs(
100. * (fluxes['Jout_tv'] - fluxes['Jout_cons'] -
fluxes.get('tv_cons', 0.)) / fluxes['Jout_tv'])
return fluxes
def write(gmeasure, name):
# do the sampling
gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups(
po2group)
smpl, fluxes = detailedo2.sampleVessels(
po2group, gvessels, gtumor, sample_length)
#cons = dataman.detailedPO2_consumption(po2group, gtumor)
cons = dataman.obtain_data('detailedPO2_consumption', po2group,
gtumor)
# get the raw data, just for the consumption flux
po2vessels, ld, po2field, parameters = dataman.obtain_data(
'detailedPO2', po2group)
avgCons = np.asarray(myutils.largeDatasetAverage(cons),
dtype=np.float64)
fluxes['Jout_cons'] = avgCons * np.product(
cons.shape) * (ld.scale * 1.e-4)**3
del po2vessels, po2field, ld
gmeasure = gmeasure.create_group(name)
for k, v in smpl.iteritems():
gmeasure.create_dataset('smpl_' + k,
data=v,
compression=9,
dtype=np.float32)
for k, v in fluxes.iteritems():
gmeasure.create_dataset('flux_' + k,
data=v) # scalar dataset
version_id = myutils.checksum(sample_length, 3, getuuid_(po2group))
ret = myutils.hdf_data_caching(
read, write, cachelocation[0],
(cachelocation[1], 'samples_and_fluxes'), (None, version_id))
return ret
if dataname == 'detailedPO2_global':
prop, po2group, sample_length, cachelocation = args
samplelocation = MakeSampleLocation(po2group)
def write(gmeasure, measurename):
assert prop == measurename
gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups(
po2group)
if prop in ['po2', 'sat', 'gtv', 'jtv']:
w = dataman.obtain_data('basic_vessel_samples', 'weight',
gvessels, sample_length)
d = dataman.obtain_data('detailedPO2_samples', prop,
po2group, sample_length, 1,
samplelocation)
gmeasure.create_dataset(prop,
data=myutils.WeightedAverageStd(
d, weights=w))
elif prop in ['sat_vein', 'sat_capi', 'sat_art']:
w = dataman.obtain_data('basic_vessel_samples', 'weight',
gvessels, sample_length)
d = dataman.obtain_data('detailedPO2_samples', 'sat',
po2group, sample_length, 1,
samplelocation)
f = dataman.obtain_data('basic_vessel_samples', 'flags',
gvessels, sample_length)
mask = ~myutils.bbitwise_and(
f, krebsutils.WITHIN_TUMOR) & myutils.bbitwise_and(
f, krebsutils.CIRCULATED)
m = {
'sat_vein': krebsutils.VEIN,
'sat_capi': krebsutils.CAPILLARY,
'sat_art': krebsutils.ARTERY
}
mask &= myutils.bbitwise_and(f, m[prop])
d, w = d[mask], w[mask]
gmeasure.create_dataset(prop,
data=myutils.WeightedAverageStd(
d, weights=w))
elif prop in [
'e1', 'e2', 'e3', 'Jin_root', 'Jout_root', 'Jout_tv',
'tv_cons', 'Jout_cons'
]:
d = dataman.obtain_data('detailedPO2_total_fluxes', prop,
po2group, sample_length, 1,
samplelocation)
gmeasure.create_dataset(prop, data=[d[prop], 0])
elif prop == 'po2_tissue':
_, po2ld, po2field, parameters = dataman.obtain_data(
'detailedPO2', po2group)
d = myutils.largeDatasetAverageAndStd(po2field)
gmeasure.create_dataset(prop, data=d)
elif prop == 'mro2':
uptakefield = detailedo2.computeO2Uptake(po2group, gtumor)
d = myutils.largeDatasetAverageAndStd(uptakefield)
gmeasure.create_dataset(prop, data=d)
elif prop in ('sat_via_hb_ratio', 'vfhb_oxy', 'vfhb_deoxy',
'vfhb'):
weight = dataman.obtain_data('basic_vessel_samples',
'weight', gvessels,
sample_length)
flags = dataman.obtain_data('basic_vessel_samples',
'flags', gvessels,
sample_length)
mask = myutils.bbitwise_and(flags, krebsutils.CIRCULATED)
hema = dataman.obtain_data('basic_vessel_samples',
'hematocrit', gvessels,
sample_length)[mask]
sat = dataman.obtain_data('detailedPO2_samples', 'sat',
po2group, sample_length, None,
samplelocation)[mask]
rad = dataman.obtain_data('basic_vessel_samples', 'radius',
gvessels, sample_length)[mask]
weight = weight[mask]
hbvolume = weight * rad * rad * math.pi * hema
ld = krebsutils.read_lattice_data_from_hdf(
po2group['field_ld'])
volume = np.product(ld.GetWorldSize())
if prop == 'sat_via_hb_ratio':
result = np.sum(hbvolume * sat) / np.sum(hbvolume)
elif prop == 'vfhb_oxy':
result = np.sum(hbvolume * sat) / volume
elif prop == 'vfhb_deoxy':
result = np.sum(hbvolume * (1. - sat)) / volume
elif prop == 'vfhb':
result = np.sum(hbvolume) / volume
gmeasure.create_dataset(prop, data=[result, 0.])
elif prop in ('chb_oxy', 'chb_deoxy', 'chb'):
m = {
'chb_oxy': 'vfhb_oxy',
'chb_deoxy': 'vfhb_deoxy',
'chb': 'vfhb'
}
result = dataman.obtain_data('detailedPO2_global', m[prop],
po2group, sample_length,
cachelocation)
result = result * detailedo2.chb_of_rbcs
gmeasure.create_dataset(prop, data=[result, 0.])
elif prop == 'mro2_by_j':
fluxes = dataman.obtain_data('detailedPO2_total_fluxes',
prop, po2group, sample_length,
1)
ld = krebsutils.read_lattice_data_from_hdf(
po2group['field_ld'])
worldbb = ld.worldBox
result = fluxes['Jout_tv'] / np.prod(worldbb[1] -
worldbb[0]) * 1.e12
gmeasure.create_dataset(prop, data=[result, 0.])
elif prop == 'oef':
fluxes = dataman.obtain_data('detailedPO2_total_fluxes',
prop, po2group, sample_length,
1, samplelocation)
result = (fluxes['Jin_root'] -
fluxes['Jout_root']) / fluxes['Jin_root']
gmeasure.create_dataset(prop, data=[result, 0.])
else:
assert False
def read(gmeasure, measurename):
d = np.asarray(gmeasure[measurename])
if measurename in ('chb_oxy', 'chb', 'chb_deoxy'):
d *= 1.e6
return d[0] # its a tuple (avg, std), we want avg now.
version_num = collections.defaultdict(lambda: 3)
version_id = myutils.checksum(sample_length, version_num[prop],
getuuid_(po2group))
#version_id = myutils.checksum(sample_length, (2 if prop in else 1))
return myutils.hdf_data_caching(read, write, cachelocation[0],
('global', cachelocation[1], prop),
(1, 1, version_id))
if dataname == 'detailedPO2_radial':
po2group, sample_length, bins_spec, distance_distribution_name, cachelocation = args
samplelocation = MakeSampleLocation(po2group)
# we assume that there is a tumor. without this measurement makes little sense
def read(gmeasure, name):
d = dict(gmeasure[name].items())
d = dict(
(k, myutils.MeanValueArray.read(v)) for k, v in d.items())
hbo = d['vfhb_oxy']
hbd = d['vfhb_deoxy']
hb = myutils.MeanValueArray(hbo.cnt, hbo.sum + hbd.sum,
hbo.sqr + hbd.sqr)
d['vfhb'] = hb
sat = hbo.avg / hb.avg
d['sat_via_hb_ratio'] = myutils.MeanValueArray(
np.ones_like(hb.cnt), sat, sat * sat)
d['chb_oxy'] = d['vfhb_oxy'] * detailedo2.chb_of_rbcs * 1.e6
d['chb_deoxy'] = d['vfhb_deoxy'] * detailedo2.chb_of_rbcs * 1.e6
d['chb'] = d['vfhb'] * detailedo2.chb_of_rbcs * 1.e6
return d
def write(gmeasure, name):
gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups(
po2group)
weight_smpl = dataman.obtain_data('basic_vessel_samples',
'weight', gvessels,
sample_length)
flags = dataman.obtain_data('basic_vessel_samples', 'flags',
gvessels, sample_length)
# get teh radial distance function (either distance from tumor border or distance from center)
dist_smpl, distmap, mask, tumor_ld = dataman.obtain_data(
'distancemap_samples', gvessels, gtumor, sample_length,
distance_distribution_name, None)
# tumor_ld might actually be a unrelated lattice
#filter uncirculated
mask = mask & myutils.bbitwise_and(flags,
krebsutils.CIRCULATED)
dist_smpl = dist_smpl[mask]
weight_smpl = weight_smpl[mask]
bins = bins_spec.arange()
gmeasure = gmeasure.create_group(name)
for name in ['po2', 'extpo2', 'jtv', 'sat', 'gtv', 'dS_dx']:
smpl = dataman.obtain_data('detailedPO2_samples', name,
po2group, sample_length, None,
samplelocation)
myutils.MeanValueArray.fromHistogram1d(
bins, dist_smpl, smpl[mask],
w=weight_smpl).write(gmeasure, name)
del smpl
_, po2ld, po2field, parameters = dataman.obtain_data(
'detailedPO2', po2group)
po2field = krebsutils.resample_field(np.asarray(po2field),
po2ld.worldBox,
tumor_ld.shape,
tumor_ld.worldBox,
order=1,
mode='nearest')
myutils.MeanValueArray.fromHistogram1d(bins, distmap.ravel(),
po2field.ravel()).write(
gmeasure,
'po2_tissue')
del po2field
uptakefield = detailedo2.computeO2Uptake(po2group, gtumor)
uptakefield = krebsutils.resample_field(uptakefield,
po2ld.worldBox,
tumor_ld.shape,
tumor_ld.worldBox,
order=1,
mode='nearest')
myutils.MeanValueArray.fromHistogram1d(
bins, distmap.ravel(),
uptakefield.ravel()).write(gmeasure, 'mro2')
del uptakefield
hema = dataman.obtain_data('basic_vessel_samples',
'hematocrit', gvessels,
sample_length)[mask]
sat = dataman.obtain_data('detailedPO2_samples', 'sat',
po2group, sample_length, None,
samplelocation)[mask]
rad = dataman.obtain_data('basic_vessel_samples', 'radius',
gvessels, sample_length)[mask]
hbvolume = weight_smpl * rad * rad * math.pi * hema
vol_per_bin = myutils.MeanValueArray.fromHistogram1d(
bins, distmap.ravel(), np.ones_like(
distmap.ravel())).cnt * (tumor_ld.scale**3)
tmp = myutils.MeanValueArray.fromHistogram1d(
bins, dist_smpl, hbvolume * sat)
tmp.cnt = vol_per_bin.copy()
tmp.write(gmeasure, 'vfhb_oxy')
tmp = myutils.MeanValueArray.fromHistogram1d(
bins, dist_smpl, hbvolume * (1. - sat))
tmp.cnt = vol_per_bin.copy()
tmp.write(gmeasure, 'vfhb_deoxy')
del tmp, hbvolume, vol_per_bin
version = getuuid_(po2group)
ret = analyzeGeneral.HdfCacheRadialDistribution(
(read, write), 'po2', bins_spec, distance_distribution_name,
cachelocation, version)
return ret
assert False
def obtain_data(self, dataman, dataname, *args):
if dataname == 'detailedPO2_peff_samples':
po2group, sample_length, every, cachelocation = args
gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups(po2group)
def read(gmeasure, name):
ds = gmeasure[name]
return ds[...] if every is None else ds[::every]
def write(gmeasure, name):
samplelocation = MakeSampleLocation(po2group)
parameters = dataman.obtain_data('detailedPO2Parameters',
po2group)
rad = dataman.obtain_data('basic_vessel_samples', 'radius',
gvessels, sample_length)
hema = dataman.obtain_data('basic_vessel_samples',
'hematocrit', gvessels,
sample_length)
po2 = dataman.obtain_data('detailedPO2_samples', 'po2',
po2group, sample_length, 1,
samplelocation)
mtc = detailedo2.computeMassTransferCoefficient(
rad, parameters)
blood_solubility = parameters.get(
'solubility_plasma', parameters.get('alpha_p', None))
c_o2_total = detailedo2.PO2ToConcentration(
po2, hema, parameters)
c_o2_plasma = detailedo2.PO2ToConcentration(
po2, np.zeros_like(hema), parameters
) # to get the o2 conc. in plasma i just set the amount of RBCs to zero
c_o2_plasma *= (
1.0 - hema
) # and reduce the concentration according to the volume fraction of plasma
beta_factor = c_o2_plasma / c_o2_total
peff = (1.0 / blood_solubility) * mtc * beta_factor
# print 'po2', np.average(po2)
# print 'mtc', np.average(mtc)
# print 'hema', np.average(hema)
# print 'blood_solubility', blood_solubility
# print 'c_o2_total', np.average(c_o2_total)
# print 'c_o2_plasma', np.average(c_o2_plasma)
# print 'peff', np.average(peff)
# print 'beta_factor', np.average(beta_factor)
gmeasure.create_dataset(name, data=peff, compression=9)
version_id = myutils.checksum(sample_length, 1, getuuid_(po2group))
ret = myutils.hdf_data_caching(
read, write, cachelocation[0],
(cachelocation[1], 'samples_and_fluxes', 'Peff'),
(None, None, version_id))
return ret
elif dataname == 'detailedPO2_peff_radial':
po2group, sample_length, bins_spec, distance_distribution_name, cachelocation = args
# we assume that there is a tumor. without this measurement makes little sense
def read(gmeasure, name):
return myutils.MeanValueArray.read(gmeasure[name])
def write(gmeasure, name):
samplelocation = MakeSampleLocation(po2group)
gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups(
po2group)
smpl = dataman.obtain_data('detailedPO2_peff_samples',
po2group, sample_length, None,
samplelocation)
data, = analyzeGeneral.GenerateRadialDistributions(
dataman, gvessels, gtumor, sample_length, bins_spec,
distance_distribution_name, None,
[(smpl, analyzeGeneral.radialAvgPerVessels)])
data.write(gmeasure, name)
version = myutils.checksum(2, getuuid_(po2group))
ret = analyzeGeneral.HdfCacheRadialDistribution(
(read, write), 'Peff', bins_spec, distance_distribution_name,
cachelocation, version)
return ret
# IDEA: store config stuff like sample length and distance distribution as member of the data handler for less call args
# or store it in a common config instance.
# Then allow to obtain a temporary handle on data which knows its GUID for a quick accurate check if data has changed.
# The handle probably would have to obtain the GUID from disk but this is it.
elif dataname == 'detailedPO2_peffSrho_radial':
po2group, sample_length, bins_spec, distance_distribution_name, cachelocation = args
def read(gmeasure, name):
return myutils.MeanValueArray.read(gmeasure[name])
def write(gmeasure, name):
samplelocation = MakeSampleLocation(po2group)
gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups(
po2group)
peff = dataman.obtain_data('detailedPO2_peff_samples',
po2group, sample_length, None,
samplelocation)
rad = dataman.obtain_data('basic_vessel_samples', 'radius',
gvessels, sample_length)
peff = peff * math.pi * 2. * rad
data, = analyzeGeneral.GenerateRadialDistributions(
dataman, gvessels, gtumor, sample_length, bins_spec,
distance_distribution_name, None,
[(peff, analyzeGeneral.radialAvgPerVolume)])
data.write(gmeasure, name)
version = myutils.checksum(2, getuuid_(
po2group)) # this should actually depend on the samples
ret = analyzeGeneral.HdfCacheRadialDistribution(
(read, write), 'PeffSrho', bins_spec,
distance_distribution_name, cachelocation, version)
return ret
assert False
b = myutils.MeanValueArray.fromHistogram1d(bins, distmap.ravel(), np.ones_like(distmap.ravel())) # how much tissue volume in the bins
a.cnt = b.cnt.copy()
a.sum *= 1./(tumor_ld.scale**3)
a.sqr *= a.sum**2 # length integral per tissue volume
#a *= 1.e6
elif avg_mode is radialAvgPerVessels:
a = myutils.MeanValueArray.fromHistogram1d(bins, dist_smpl, smpl[mask], weight_smpl)
else:
assert (avg_mode is radialAvgPerVolume or avg_mode is radialAvgPerVessels)
res.append(a)
return res
def HdfCacheRadialDistribution((read, write), property_name, bins_spec, distance_distribution_name, cachelocation, version):
path1 = 'radial_vs_'+distance_distribution_name+'_bins'+str(hash(bins_spec))
version_args = myutils.checksum(30., 13)
return myutils.hdf_data_caching(read, write, cachelocation[0], (path1,cachelocation[1],property_name), (version_args,0,version))
#def GetMaskUncirculated(dataman, vesselgroup):
# flags = dataman.obtain_data('basic_vessel_samples', 'flags', vesselgroup, sample_length)
# return myutils.bbitwise_and(flags, krebsutils.CIRCULATED)
def GetMaskArea(dataman, vesselgroup, tumorgroup, distance_distribution_name, ld, distmin, distmax, sample_length = 30.):
dist_smpl, distmap, mask, _ = dataman.obtain_data('distancemap_samples', vesselgroup, tumorgroup, sample_length, distance_distribution_name, ld)
mask2 = (dist_smpl>distmin) & (dist_smpl<distmax)
return mask & mask2
def ComputeSampleHistogram(dataman, vesselgroup, binspec, samples, mask = None, sample_length = 30.):
weight = dataman.obtain_data('basic_vessel_samples', 'weight', vesselgroup, sample_length)
