Example #1
0
def DoIt_single(filenames, options):
  fn_measure = basename(commonprefix(filenames))
  fn_measure = myutils.strip_from_end(fn_measure, '.h5')
  fn_measure = myutils.strip_from_end(fn_measure, '-type')

  f_measure = h5files.open('adaption_common.h5', 'a', search = False)
  
  files = [h5files.open(fn, 'r') for fn in filenames]
  groups_without_adaption = [f['/adaption/recomputed'] for f in files]
  
  groups_with_adaption = [f['/adaption/vessels_after_adaption'] for f in files]

  import analyzeGeneral
  dataman = myutils.DataManager(20, [ analyzeGeneral.DataBasicVessel(), analyzeGeneral.DataVesselSamples(), analyzeGeneral.DataVesselGlobal()])
  with mpl_utils.PdfWriter(fn_measure+'flow_hist.pdf') as pdfpages:
    if 1:
      plotFlowHistogram(dataman, f_measure, filenames, options, pdfpages)
  with mpl_utils.PdfWriter(fn_measure+'radius_hist.pdf') as pdfpages:
    if 1:
      plotRadiusHistogram(dataman, f_measure, filenames, options, pdfpages)    
  with mpl_utils.PdfWriter(fn_measure+'cap_flow_hist.pdf') as pdfpages:
    if 1:
      plotCapillaryFlowHistogram(dataman, f_measure, filenames, options, pdfpages)
  with mpl_utils.PdfWriter(fn_measure+'cap_radius_hist.pdf') as pdfpages:    
    if 1:
      plotCapillaryRadiusHistogram(dataman, f_measure, filenames, options, pdfpages)
Example #2
0
def DoIt(filenames, options):
  fn_measure = basename(commonprefix(filenames))
  fn_measure = myutils.strip_from_end(fn_measure, '.h5')
  fn_measure = myutils.strip_from_end(fn_measure, '-type')

  f_measure = h5files.open('adaption_common.h5', 'a', search = False)
  
  files = [h5files.open(fn, 'r') for fn in filenames]
  groups_without_adaption = [f['/adaption/recomputed'] for f in files]
  
  groups_with_adaption = [f['/adaption/vessels_after_adaption'] for f in files]


  with mpl_utils.PdfWriter(fn_measure+'caps.pdf') as pdfpages:
    import analyzeGeneral
    dataman = myutils.DataManager(20, [ analyzeGeneral.DataBasicVessel(), analyzeGeneral.DataVesselSamples(), analyzeGeneral.DataVesselGlobal()])
#    vesselgroups_without = groups_without_adaption
#    vesselgroups_with = groups_with_adaption
    
#    geometric_data_before = getGeometricData(groups_without_adaption)
#    perfusion_data_before = getTotalPerfusion(groups_without_adaption)*60
    
#    geometric_data_after = getGeometricData(groups_with_adaption)
#    perfusion_data_after = getTotalPerfusion(groups_with_adaption)*60
    if 1:
      plotFlowHistogram(dataman, f_measure, filenames, options, pdfpages)
      
    if 1:
      plotRadiusHistogram(dataman, f_measure, filenames, options, pdfpages)    
    
    if 1:
      plotCapillaryFlowHistogram(dataman, f_measure, filenames, options, pdfpages)
      
    if 1:
      plotCapillaryRadiusHistogram(dataman, f_measure, filenames, options, pdfpages)
Example #3
0
def DoIt(inputFileNames, pattern, options):
    for this_enlargement_factor in options.enlarge_factor:
        inFiles = [h5files.open(fn, 'r') for fn in inputFileNames]

        inGroups = list(
            itertools.chain.from_iterable(
                myutils.walkh5(f, pattern, return_h5objects=True)
                for f in inFiles))
        if len(inGroups) <= 0:
            print 'no matching groups in hdf file(s)'
            sys.exit(0)
        for in_file in inputFileNames:
            bloodflowparams = krebsutils.pyDictFromParamGroup(
                h5files.open(in_file, 'r')['parameters/calcflow'])
            #enlarge_vessels(float(this_enlargement_factor),in_file, bloodflowparams)

            qsub.submit(
                qsub.func(enlarge_vessels, float(this_enlargement_factor),
                          in_file, bloodflowparams),
                name='job_modify_enlarge_' + str(this_enlargement_factor) +
                '_',
                num_cpus=6,
                days=
                5,  # about one day per thread, the idea being that number of threads is proportional to systems size and runtime is 
                mem='%iMB' % (1000),
                change_cwd=True)
Example #4
0
def plotFlowHistogram(dataman, f_measure, filenames, options, pdfpages):
    filenames = adaption.get_files_with_successful_adaption(filenames)
    files = [h5files.open(fn, 'r') for fn in filenames]
    destination_group = f_measure.require_group('allFlow')
    if(options.two):
      typelist = 'typeD- typeE- typeG- typeH-'
    else:
      typelist = 'typeA- typeB- typeC- typeF- typeI-'
    if(options.all_types):
      typelist = 'typeA- typeB- typeC- typeD- typeE- typeF- typeG- typeH- typeI-'
      
    if(options.single):
      typelist = 'typeF- '
      
    fig = plt.figure()
    #fig.suptitle('all Flows', fontsize=12)
    #fig.set_title('all Flows')
    ax1 = fig.add_subplot(211)
    ax2 = fig.add_subplot(212)
    ax1.set_title('M- network')
    ax1.set_xlabel(r'flow/$\frac{\mu m^3}{s}$')
    ax1.set_ylabel(r'$\rho$')
    ax1.text(-0.1, 1.15, 'A', transform=ax1.transAxes,fontsize=16, fontweight='bold', va='top', ha='right')
    ax2.set_title('Adapted- network')
    ax2.set_xlabel(r'flow/$\frac{\mu m^3}{s}$')
    ax2.set_ylabel(r'$\rho$')
    ax2.text(-0.1, 1.15, 'B', transform=ax2.transAxes,fontsize=16, fontweight='bold', va='top', ha='right')
    
    for (i,t) in enumerate(typelist.split()):
      print('Capillary flow for type: %s' % t)
      filteredFiles = filter( lambda fn: t in fn,filenames) 
      files = [h5files.open(fn, 'r+') for fn in filteredFiles]
  
      if(len(files)==0):#that means no file of dedicated type is left after filter
        continue        
        #h_nA, h_yA, x_edges_nA, x_edges_yA = generate_capillary_hist(dataman, files, destination_group, t[:-1])
      #data = generate_murray_data_plot3(dataman, files, destination_group, t[:-1])      
      else:
        h_nA,h_yA,xedges_nA,xedges_yA = generate_flow_hist(dataman, files, destination_group, t[:-1] + '_allFlow')
        xedges_nA = np.asarray(xedges_nA)
        xedges_yA = np.asarray(xedges_yA)
        h1 =np.asarray(h_nA)
        h2 =np.asarray(h_yA)
        ax1.plot((xedges_nA[1:]+xedges_nA[:-1])/2, h1,  label = type_to_label_dict[t], marker= vesselTypeMarkers[i], color=colors[i])
        ax2.plot((xedges_yA[1:]+xedges_yA[:-1])/2, h2,  label = type_to_label_dict[t], marker= vesselTypeMarkers[i], color=colors[i])
          
    fontP = FontProperties()
    fontP.set_size('x-small')
    ax1.legend(prop=fontP)
    if double_log:
      ax2.loglog()
      ax1.loglog()
    else:
      ax2.semilogx()
      ax1.semilogx()
    
    plt.tight_layout()
    pdfpages.savefig(fig)
    def render(self):
        """ run povray. This should be called on the computing node. """
        with h5files.open(self.fn, 'a') as f:
            if 'po2vessels' in f[self.group_name]:
                from krebs.povrayRenderOxygenDetailed import renderScene
                renderScene(f[self.group_name], self.imageFilename,
                            self.params)

            elif 'tumor' in f[self.group_name]:
                from krebs.povrayRenderTumor import renderScene
                self.params.timepoint = f[self.group_name].attrs.get('time')
                renderScene(f[self.group_name]['vessels'],
                            f[self.group_name]['tumor'], self.imageFilename,
                            self.params)


#      else:
#        from krebs.povrayRenderVessels import renderScene
#        renderScene(f[self.group_name],
#                    self.imageFilename,
#                    **self.params)
#renderScene(drug_grp, imagefn, parameters)
            elif 'conc' in f[self.group_name]:
                from krebs.povrayRenderIff import renderScene
                renderScene(f[self.group_name], self.imageFilename,
                            self.params)
            else:
                from krebs.povrayRenderVessels import render_different_data_types
                render_different_data_types(f[self.group_name], self.params)
def run(goodArguments):
    print('starting with arguments: %s' % goodArguments)
    no_files = len(goodArguments.oxygenFiles)

    hypoxicVolumes = []
    tumorVolumes = []
    threshold = 15
    test = myutils.MeanValueArray.empty()
    for aFile in goodArguments.oxygenFiles:
        with h5files.open(aFile.name) as f:
            try:
                if not 'po2' in f:
                    raise AssertionError('no proper oxygen file: %s!' % f)
            except Exception, e:
                print e.message
                sys.exit(-1)
            paths = myutils.walkh5(f, 'po2/out*')
            print('found paths: %s' % paths)
            hypoxicVolumes_per_time = []
            tumorVolumes_per_time = []
            timepoints = []
            for path in paths:
                hypoxicFraction, hypoxicTissueVolume = estimate_ratio_hypoxic(
                    f[path], threshold)
                hypoxicVolumes_per_time.append(hypoxicTissueVolume)
                t = f[path]['SOURCE'].attrs['time']
                r = f[path]['SOURCE/tumor'].attrs['TUMOR_RADIUS']
                volume = 4 / 3. * 3.1414 * r * r * r / 1e9
                tumorVolumes_per_time.append(volume)
                timepoints.append(t)
            hypoxicVolumes.append(hypoxicVolumes_per_time)
            tumorVolumes.append(tumorVolumes_per_time)
 def __init__(self, dataman, filenames, pattern):
     files = [h5files.open(fn, 'r+') for fn in filenames]
     items = []
     has_tumor = True
     for f in files:
         paths = myutils.walkh5(f['.'], pattern)
         for path in paths:
             g = f[path]
             if g.attrs.get('CLASS', None) == 'GRAPH':
                 gvessels = g
                 gtumor = None
                 try:
                     source = h5files.openLink(g, 'SOURCE')
                     gtumor = source.parent['tumor']
                     g = source.parent
                 except Exception, e:
                     raise RuntimeError(
                         'tried to get tumor data but failed:' + str(e))
             else:
                 gvessels, gtumor = g['vessels'], (g['tumor'] if 'tumor'
                                                   in g else None)
             e = EnsembleItem(path=path,
                              gvessels=gvessels,
                              gtumor=gtumor,
                              group=g)
             e.time = g.attrs['time']
             has_tumor = has_tumor and gtumor is not None
             e.vessel_system_length = dataman.obtain_data(
                 'vessel_system_length', gvessels)
             items.append(e)
def DoReadIn(filenames, pattern, fn_measure,pdf,quantity):
    #read in lots of stuff
    files = [h5files.open(fn, 'r') for fn in filenames]
    output_f = h5py.File(fn_measure)
    
    if quantity == 'flow':
      iflog=True
    else:
      iflog=False
    if quantity == 'shearforce':
      iflog=True
    for t in 'typeA typeB typeC typeD typeE typeF typeG typeH typeI'.split():
      #edges
      fig1 = plt.figure()
      plt.plot()
      ax1 = plt.axes()
      if 'all_flows_of_type_dist' in locals():
          del all_flows_of_type_dist
      for afile in files:
        print(t)
        if t in afile.filename:
          print("where in")
          if iflog:
            flows_in_a_file = np.asarray(afile[pattern + '/edges/'+quantity])
            flows_in_a_file = flows_in_a_file[np.nonzero(flows_in_a_file)]
            flows_in_a_file = np.log10(flows_in_a_file)
            if quantity == 'flow':
              flows_in_a_file = np.asarray(afile[pattern + '/edges/'+quantity])
              flows_in_a_file = flows_in_a_file[np.nonzero(flows_in_a_file)]              
              fac=60/100000.
              flows_in_a_file = np.multiply(fac,flows_in_a_file)
              flows_in_a_file = np.log10(flows_in_a_file)
          else:
            flows_in_a_file = np.asarray(afile[pattern + '/edges/'+quantity])
          flow_dist, bin_edges = np.histogram(flows_in_a_file, bins=50, density=True)          
          if 'all_flows_of_type_dist' in locals():
            all_flows_of_type_dist = np.vstack((all_flows_of_type_dist,flow_dist))
          else:
            all_flows_of_type_dist = flow_dist
      
      if 'all_flows_of_type_dist' in locals():
        fig1.suptitle(t)
        ax1.grid()
        if quantity == 'flow':
          ax1.set_xlabel(r'\log_{10}(flow)/nl/min')
          
        elif quantity == 'radius':
          ax1.set_xlabel(r'radius/\mu m')
        ax1.set_ylabel('probability')
        width = 1*(bin_edges[1]-bin_edges[0])
        centers = (bin_edges[:-1]+bin_edges[1:])/2
        
        if len(all_flows_of_type_dist.shape)==1:
          ax1.plot(centers,all_flows_of_type_dist,'*')
        else:
          ys = np.mean(all_flows_of_type_dist,0)
          yerr = np.std(all_flows_of_type_dist,0)
          ax1.errorbar(centers,ys,yerr=yerr)
          
        pdf.savefig()
Example #9
0
def getDomainSizeFromVesselFile(fn):
    with h5files.open(fn, 'r') as f:
        ld = krebsutils.read_lattice_data_from_hdf(
            krebsutils.find_lattice_group_(f['vessels']))
        size = np.amax(ld.GetWorldSize())
    # longest axis times the lattice spacing
    return size
def create_mean_plot_velocities():
    my_res_file = h5files.open('analyzeVesselTumor.h5', 'r')
    count_hists = 0
    the_keys = my_res_file['/global'].keys()
    print(the_keys[0])
    no_bins = 55
    the_density_in = np.zeros(no_bins - 1)
    the_density_out = np.zeros(no_bins - 1)
    for key in my_res_file['/global'].keys():
        print('working with %s' % key)
        count_hists = count_hists + 1
        count_in = my_res_file['/global/%s/flows_within_tumor/flows_inside' %
                               key]
        count_out = my_res_file['/global/%s/flows_within_tumor/flows_outside' %
                                key]
        radii_in = np.asarray(
            my_res_file['/global/%s/radii_within_tumor/radii_inside' % key])
        radii_out = np.asarray(
            my_res_file['/global/%s/radii_within_tumor/radii_outside' % key])
        count_in = np.asarray(count_in) / (np.pi * np.square(radii_in))
        count_out = np.asarray(count_out) / (np.pi * np.square(radii_out))
        density_in, bin_in_array = np.histogram(count_in,
                                                np.logspace(1, 4, no_bins),
                                                density=True)
        density_out, bin_out_array = np.histogram(count_out,
                                                  np.logspace(1, 4, no_bins),
                                                  density=True)
        the_density_in = the_density_in + density_in
        the_density_out = the_density_out + density_out
    print('we have %i histograms' % count_hists)
    the_density_in = np.divide(the_density_in, count_hists)
    the_density_out = np.divide(the_density_out, count_hists)
    mu1 = np.sum(the_density_in * np.diff(bin_in_array) *
                 (0.5 * (bin_in_array[1:] + bin_in_array[:-1])))
    quad1 = np.sum(the_density_in * np.diff(bin_in_array) * np.square(
        (0.5 * (bin_in_array[1:] + bin_in_array[:-1]))))
    std1 = np.sqrt(quad1 - mu1**2)
    mu2 = np.sum(the_density_out * np.diff(bin_out_array) *
                 (0.5 * (bin_out_array[1:] + bin_out_array[:-1])))
    quad2 = np.sum(the_density_out * np.diff(bin_out_array) * np.square(
        (0.5 * (bin_out_array[1:] + bin_out_array[:-1]))))
    std2 = np.sqrt(quad2 - mu2**2)
    plt.title('Flow distribution')
    ax = plt.subplot(211)
    ax.bar(bin_out_array[:-1], the_density_out, np.diff(bin_out_array))
    ax.set_xscale('log')
    ax.text(10**3, 0.002, '$< v_{out} > = %f \pm %f$' % (mu2, std2))
    plt.legend(['Outside'])
    plt.ylabel('Propability')
    ax = plt.subplot(212)
    ax.bar(bin_in_array[:-1], the_density_in, np.diff(bin_in_array))
    ax.set_xscale('log')
    ax.text(10**2, 0.006, '$< v_{in} > = %f \pm %f$' % (mu1, std1))
    plt.xlabel('Volumeflow through vessel segments/ $\mu m$')
    plt.ylabel('Propability')

    plt.legend(['Inside'])
    plt.savefig('Flow_distribution.png')

    plt.show()
Example #11
0
 def find_enlargement_factors(filenames):
     factors = []
     files = [h5files.open(fn, 'r+') for fn in filenames]
     for f in files:
         if 'enlargeFactor' in f.attrs.keys():
             if not f.attrs.get('enlargeFactor') in factors:
                 factors.append(f.attrs.get('enlargeFactor'))
     return factors
Example #12
0
def from_vessel_file(filenames, grp_pattern):
    dirs = set()
    dataman = myutils.DataManager(20, [
        krebs.plotIff.DataTissue(),
        krebs.plotIff.DataGlobalIff(),
        krebs.plotIff.DataRadialIff(),
        krebs.analyzeGeneral.DataDistanceFromCenter(),
        krebs.analyzeGeneral.DataVesselSamples(),
        krebs.analyzeGeneral.DataBasicVessel(),
        o2analysis.DataDetailedPO2()
    ])
    f_measure = h5files.open('chache.h5', 'a', search=False)

    def cachelocation(g):
        path = posixpath.join(
            'FileCS_' + myutils.checksum(basename(g.file.filename)),
            g.name.strip(posixpath.sep))
        return (f_measure, path)

    #run with grp_pattern: iff/vessels
    for fn in filenames:
        with h5py.File(fn, 'r+') as f:
            d = myutils.walkh5(f, grp_pattern)
            assert len(d), 'you f****d up, pattern "%s" not found in "%s"!' % (
                grp_pattern, fn)
            dirs = set.union(dirs, d)
            for group_path in dirs:
                if 'vessel' in grp_pattern and not 'o2' in grp_pattern:
                    vesselgroup = f[group_path]
                    ldvessels = ku.read_lattice_data_from_hdf(
                        vesselgroup['lattice'])
                    fieldld = ku.SetupFieldLattice(ldvessels.worldBox, 3, 10,
                                                   0.)
                    phi_vessels = krebs.analyzeGeneral.CalcPhiVessels(
                        dataman,
                        vesselgroup,
                        fieldld,
                        scaling=1.,
                        samples_per_cell=5)
                    print('bla')
                    import nibabel as nib
                    new_image = nib.Nifti1Image(phi_vessels, affine=np.eye(4))
                    common_filename = os.path.splitext(os.path.basename(fn))[0]
                    new_image.to_filename(common_filename + '_vessels' +
                                          '.nii')
                if 'o2' in grp_pattern:
                    po2group = f[group_path]
                    #sample_length = 500.
                    #data = dataman.obtain_data('detailedPO2_global', 'po2_tissue', po2group, sample_length, cachelocation(po2group))
                    data = np.asarray(po2group['po2field'])
                    print('bla')
                    import nibabel as nib
                    new_image = nib.Nifti1Image(data, affine=np.eye(4))
                    common_filename = os.path.splitext(os.path.basename(fn))[0]
                    new_image.to_filename(common_filename + '_po2' + '.nii')
Example #13
0
 def __init__(self, dataman, filenames, pattern):
     files = [h5files.open(fn, 'r+') for fn in filenames]
     items = []
     has_tumor = True
     for f in files:
         paths = myutils.walkh5(f['.'], pattern)
         for path in paths:
             po2group_w_a = f[path + '/vessels_after_adaption']
             gvessels_w_a, gtumor = detailedo2.OpenVesselAndTumorGroups(
                 po2group_w_a)
             po2group_no_a = f[path + '/recomputed']
             gvessels_no_a, gtumor = detailedo2.OpenVesselAndTumorGroups(
                 po2group_no_a)
             e = EnsembleItem(path=path,
                              po2group_w_a=po2group_w_a,
                              gvessels_w_a=gvessels_w_a,
                              po2group_no_a=po2group_no_a,
                              gvessels_no_a=gvessels_no_a,
                              gtumor=gtumor)
             #        if 'SOURCE' in po2group:
             #          source = h5files.openLink(po2group, 'SOURCE')
             #          if 'time' in source.attrs.keys():
             #            t = source.attrs['time']
             #            e.time = t
             has_tumor = has_tumor and gtumor is not None
             e.vessel_system_length = dataman.obtain_data(
                 'vessel_system_length', gvessels_no_a)
             e.initialVesselType = GetVesselTypeLabel(po2group_no_a)
             items.append(e)
     if has_tumor:
         d = collections.defaultdict(list)  # path -> list of EnsembleItem
         for e in items:
             d[e.path].append(e)
         tumor_snapshot_times = dict(
             (k, np.average(map(lambda e: e.time, v)))
             for k, v in d.items())
         tumor_snapshot_order = sorted(
             tumor_snapshot_times.keys(),
             key=(lambda path: tumor_snapshot_times[path]))
         tumor_snapshots = [(d[path], path, tumor_snapshot_times[path])
                            for path in tumor_snapshot_order]
     self.files = files
     self.items = items
     if has_tumor:
         self.tumor_snapshots = tumor_snapshots  # list of tuple(items, path, time)
         self.has_tumor = has_tumor
     self.o2ConfigName = set(
         item.po2group_no_a.attrs.get('O2_CONFIG_NAME', None)
         for item in items)
     if len(self.o2ConfigName) != 1:
         raise RuntimeError(
             "Detected different O2_CONFIG_NAMES %s. You don't want to mix configurations, do you?"
             % self.o2ConfigName)
     self.o2ConfigName = self.o2ConfigName.pop()
Example #14
0
def enlarge_vessels(factor, gv_filename, bloodflowparams):
    '''gvdst = group where the data is placed in, does not create a 'vesse' folder in it but writes nodes, edges directly;
     gv   = source vessel group
  '''
    inFile = h5files.open(gv_filename, 'r')
    gv = inFile['vessels']
    fac_as_percent = int(np.ceil(float(factor) * 100 - 100))
    dest_file = h5files.open(
        myutils.strip_from_end(gv_filename, '.h5') +
        '_growth_by_%02i.h5' % fac_as_percent, 'a')
    dest_file.attrs.create('enlargeFactor', data=fac_as_percent)
    gvdst = dest_file.create_group('vessels')
    gvdst.attrs['CLASS'] = 'GRAPH'
    myutils.buildLink(gvdst, 'SOURCE', gv)
    # first we need to copy some of the vessel data
    gvedst = gvdst.create_group('edges')
    gvndst = gvdst.create_group('nodes')
    gvedst.attrs['COUNT'] = gv['edges'].attrs['COUNT']
    gvndst.attrs['COUNT'] = gv['nodes'].attrs['COUNT']
    gv.copy('lattice', gvdst)
    for name in [
            'lattice_pos', 'roots', 'nodeflags', 'gf', 'bc_conductivity_value',
            'bc_node_index', 'bc_type', 'bc_value'
    ]:
        gv['nodes'].copy(name, gvndst)
    for name in ['radius', 'node_a_index', 'node_b_index', 'flags']:
        if name == 'radius':
            radii = gv['edges/' + name]
            radii = factor * np.asarray(radii)
            gvedst.create_dataset(name, data=radii)
        else:
            gv['edges'].copy(name, gvedst)
    # then we recompute blood flow because the alorithm has changed and we may or may not want hematocrit
    (pressure, flow, shearforce, hematocrit,
     flags) = krebsutils.calc_vessel_hydrodynamics(
         gvdst, return_flags=True, bloodflowparams=bloodflowparams)
    # then we save the new data to complete the network copy
    gvedst.create_dataset('flow', data=flow, compression=9)
    gvedst.create_dataset('shearforce', data=shearforce, compression=9)
    gvedst.create_dataset('hematocrit', data=hematocrit, compression=9)
    gvndst.create_dataset('pressure', data=pressure, compression=9)
Example #15
0
def doit(filenames):
    dataman = myutils.DataManager(
        50,
        map(lambda x: x(), detailedo2Analysis.O2DataHandlers) + [
            analyzeGeneral.DataTumorTissueSingle(),
            analyzeGeneral.DataDistanceFromCenter(),
            analyzeGeneral.DataBasicVessel(),
            analyzeGeneral.DataVesselSamples(),
            analyzeGeneral.DataVesselRadial(),
            analyzeGeneral.DataVesselGlobal(),
            analyzeBloodFlow.DataTumorBloodFlow()
        ])
    ensemble = EnsembleFiles(dataman, filenames, 'po2/adaption/')
    out_prefix, out_suffix = myutils.splitcommonpresuffix(
        map(lambda s: basename(s), filenames))
    output_base_filename = splitext(out_prefix + out_suffix)[0]
    if ensemble.o2ConfigName:
        fn_measure = 'detailedo2_%s_common.h5' % ensemble.o2ConfigName
    else:
        fn_measure = 'detailedo2_common.h5'

    f_measure = h5files.open(fn_measure, 'a')

    def cachelocation(g):
        path = posixpath.join(
            'FileCS_' + myutils.checksum(basename(g.file.filename)),
            g.name.strip(posixpath.sep))
        return (f_measure, path)

    measurementinfo = MeasurementInfo(sample_length=30.,
                                      cachelocation_callback=cachelocation,
                                      distancemap_spec='radial')

    with mpl_utils.PageWriter(output_base_filename + '.pdf',
                              fileformats=['pdf']) as pdfwriter:
        if 0:
            compare_tissue_saturation(dataman, ensemble, pdfwriter)

        if 0:
            #try:
            #  histogramGroupFinal   = f_measure['combinedHistogramsFinal']
            #  histogramGroupInitial = f_measure['combinedHistogramsInitial']
            #except KeyError:

            #histogramGroupFinal   = f_measure.recreate_group('combinedHistogramsFinal')
            histogramGroupInitial = f_measure.recreate_group(
                'combinedHistogramsInitial')
            #ComputeHistogramsOfPo2Items(dataman, ensemble.items, measurementinfo, histogramGroupFinal)
            ComputeHistogramsOfPo2Items(dataman, ensemble.items,
                                        measurementinfo, histogramGroupInitial)
            #PlotHistograms(pdfwriter, histogramGroupFinal, 'tum', 'Tumor')
            PlotHistograms(pdfwriter, histogramGroupInitial, 'all', 'Initial')
def create_mean_plot_radii():
    my_res_file = h5files.open('analyzeVesselTumor.h5', 'r')
    count_hists = 0
    the_keys = my_res_file['/global'].keys()
    print(the_keys[0])
    no_bins = 55
    the_density_in = np.zeros(no_bins)
    the_density_out = np.zeros(no_bins)
    for key in my_res_file['/global'].keys():
        print('working with %s' % key)
        count_hists = count_hists + 1
        count_in = my_res_file['/global/%s/radii_within_tumor/radii_inside' %
                               key]
        count_out = my_res_file['/global/%s/radii_within_tumor/radii_outside' %
                                key]
        density_in, bin_in_array = np.histogram(count_in,
                                                no_bins,
                                                density=True)
        density_out, bin_out_array = np.histogram(count_out,
                                                  no_bins,
                                                  density=True)
        the_density_in = the_density_in + density_in
        the_density_out = the_density_out + density_out
    print('we have %i histograms' % count_hists)
    the_density_in = np.divide(the_density_in, count_hists)
    the_density_out = np.divide(the_density_out, count_hists)
    mu1 = np.sum(the_density_in * np.diff(bin_in_array) *
                 (0.5 * (bin_in_array[1:] + bin_in_array[:-1])))
    quad1 = np.sum(the_density_in * np.diff(bin_in_array) * np.square(
        (0.5 * (bin_in_array[1:] + bin_in_array[:-1]))))
    std1 = np.sqrt(quad1 - mu1**2)
    mu2 = np.sum(the_density_out * np.diff(bin_out_array) *
                 (0.5 * (bin_out_array[1:] + bin_out_array[:-1])))
    quad2 = np.sum(the_density_out * np.diff(bin_out_array) * np.square(
        (0.5 * (bin_out_array[1:] + bin_out_array[:-1]))))
    std2 = np.sqrt(quad2 - mu2**2)
    plt.title('Radii distribution')
    ax = plt.subplot(211)
    ax.bar(bin_out_array[:-1], the_density_out, np.diff(bin_out_array))
    ax.text(30, 0.2, '$< r_{out} > = %f \pm %f$' % (mu2, std2))
    plt.legend(['Outside'])
    plt.ylabel('Propability')
    ax = plt.subplot(212)
    plt.bar(bin_in_array[:-1], the_density_in, np.diff(bin_in_array))
    ax.text(20, 0.3, '$< r_{in} > = %f \pm %f$' % (mu1, std1))
    plt.xlabel('radius of vessel segments/ $\mu m$')
    plt.ylabel('Propability')

    plt.legend(['Inside'])
    plt.savefig('Radii_distribution.png')

    plt.show()
Example #17
0
def worker_on_client(fn, pattern, o2params):
    print 'detailedo2 on %s / %s' % (fn, pattern)
    h5files.search_paths = [
        dirname(fn)
    ]  # so the plotting and measurement scripts can find the original tumor files using the stored basename alone
    #no, this is not working!!!!, hand num_threads over to the cpp side
    #num_threads = o2params.pop('num_threads')
    #krebsutils.set_num_threads(num_threads)
    o2_refs = detailedo2.doit(fn, pattern, (o2params, o2params['name']))
    if 0:  #this is for data analysis on the clusters
        for ref in o2_refs:
            po2group = h5files.open(ref.fn)[ref.path]
            detailedo2Analysis.WriteSamplesToDisk(po2group)
    h5files.closeall()  # just to be sure
Example #18
0
def MakeVesselFilenamePart(fn):
  with h5files.open(fn, mode='a') as f:
    if 'parameters' in f:
      if 'MESSAGE' in f['parameters'].attrs:
        msg = f['parameters'].attrs['MESSAGE']
        ensemble_index = f['parameters'].attrs['ENSEMBLE_INDEX']
        if msg.startswith('vessels-'): msg=msg[len('vessels-'):]
    if 'msg' not in locals():
      msg = "hm"
      ensemble_index = 1
      f['parameters'].attrs['MESSAGE'] = msg 
      f['parameters'].attrs['ENSEMBLE_INDEX'] = ensemble_index
    
  name = '%s-sample%02i' % (msg, ensemble_index)
  return name
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')
Example #20
0
def doit_optimize(vesselFileName, adaptParams, BfParams):
    returns = adaption_cpp.doAdaptionOptimization(vesselFileName, adaptParams,
                                                  BfParams)
    print("should be optimized vaules:")
    print(returns)
    print('from file: %s' % vesselFileName)
    f_results = h5files.open("optimize_results.h5", 'a')
    a_uuid = str(uuid.uuid4())
    g = f_results.create_group(vesselFileName + '_' + a_uuid)
    g.create_dataset('x_opt', data=returns)
    myutils.hdf_write_dict_hierarchy(g, 'adaptParams', adaptParams)
    myutils.hdf_write_dict_hierarchy(g, 'BfParams', BfParams)
    g.file.flush()
    #f_results.close()
    return returns
def run_out_in_single_file(goodArguments):
    print('starting with arguments: %s' % goodArguments)
    no_files = len(goodArguments.oxygenFiles)

    annoxicVolumes = []
    hypoxicVolumes = []
    normoxicVolumes = []
    tumorVolumes = []
    #threshold = 15
    threshold1 = 0.1
    threshold2 = 2.5
    test = myutils.MeanValueArray.empty()

    annoxicVolumes_per_time = []
    hypoxicVolumes_per_time = []
    normoxicVolumes_per_time = []
    tumorVolumes_per_time = []
    timepoints = []

    for aFile in goodArguments.oxygenFiles:
        with h5files.open(aFile.name) as f:
            try:
                if not 'po2' in f:
                    raise AssertionError('no proper oxygen file: %s!' % f)
            except Exception, e:
                print e.message
                sys.exit(-1)
            paths = myutils.walkh5(f, 'po2/out*')
            print('found paths: %s' % paths)

            for path in paths:
                #hypoxicFraction,hypoxicTissueVolume = estimate_ratio_hypoxic(f[path], threshold)
                t = f[path]['SOURCE'].attrs['time']
                r = f[path]['SOURCE/tumor'].attrs['TUMOR_RADIUS']
                volume = 4 / 3. * 3.1414 * r * r * r / 1e9
                #volume=(2*r)*(2*r)*(2*r)/1e9
                tumorVolumes_per_time.append(volume)
                t = t / (3600.0 * 24)  #days
                timepoints.append(t)
                annoxicTissueVolume, hypoxicTissueVolume, normoxicTissueVolume = estimate_annoxic_hypoxic_normoxic(
                    f[path], r, threshold1, threshold2)
                annoxicVolumes_per_time.append(annoxicTissueVolume)
                hypoxicVolumes_per_time.append(hypoxicTissueVolume)
                normoxicVolumes_per_time.append(normoxicTissueVolume)
            annoxicVolumes.append(annoxicVolumes_per_time)
            hypoxicVolumes.append(hypoxicVolumes_per_time)
            normoxicVolumes.append(normoxicVolumes_per_time)
            tumorVolumes.append(tumorVolumes_per_time)
def create_mean_plot_length():
    my_res_file = h5files.open('analyzeVesselTumor.h5', 'r')
    count_hists = 0
    the_keys = my_res_file['/global'].keys()
    print(the_keys[0])
    the_density_in = np.zeros_like(
        my_res_file['/global/%s/length_dist/inside_density' % the_keys[0]])
    the_density_out = np.zeros_like(
        my_res_file['/global/%s/length_dist/outside_density' % the_keys[0]])
    a_bin_in = my_res_file['/global/%s/length_dist/inside_bins' % the_keys[0]]
    a_bin_out = my_res_file['/global/%s/length_dist/outside_bins' %
                            the_keys[0]]
    for key in my_res_file['/global'].keys():
        print('working with %s' % key)
        count_hists = count_hists + 1
        the_density_in = the_density_in + my_res_file[
            '/global/%s/length_dist/inside_density' % key]
        the_density_out = the_density_out + my_res_file[
            '/global/%s/length_dist/outside_density' % key]
    print('we have %i histograms' % count_hists)
    the_density_in = np.divide(the_density_in, count_hists)
    the_density_out = np.divide(the_density_out, count_hists)
    mu1 = np.sum(the_density_in * np.diff(a_bin_in) *
                 (0.5 * (a_bin_in[1:] + a_bin_in[:-1])))
    quad1 = np.sum(the_density_in * np.diff(a_bin_in) * np.square(
        (0.5 * (a_bin_in[1:] + a_bin_in[:-1]))))
    std1 = np.sqrt(quad1 - mu1**2)
    mu2 = np.sum(the_density_out * np.diff(a_bin_out) *
                 (0.5 * (a_bin_out[1:] + a_bin_out[:-1])))
    quad2 = np.sum(the_density_out * np.diff(a_bin_out) * np.square(
        (0.5 * (a_bin_out[1:] + a_bin_out[:-1]))))
    std2 = np.sqrt(quad2 - mu2**2)
    plt.title('Length distribution')
    ax = plt.subplot(211)
    ax.bar(a_bin_out[:-1], the_density_out, np.diff(a_bin_out))
    ax.text(300, 0.035, '$< l_{out} > = %f \pm %f$' % (mu2, std2))
    plt.legend(['Outside'])
    plt.ylabel('Propability')
    ax = plt.subplot(212)
    plt.bar(a_bin_in[:-1], the_density_in, np.diff(a_bin_in))
    ax.text(300, 0.008, '$< l_{in} > = %f \pm %f$' % (mu1, std1))
    plt.xlabel('length of vessel segments/ $\mu m$')
    plt.ylabel('Propability')

    plt.legend(['Inside'])
    plt.savefig('Length_distribution.png')
Example #23
0
def MeasurementFile(f, h5files, prefix='measure_'):
    if not isinstance(f, (str, unicode)):
        fn = f.filename
    else:
        fn = f
    fnpath = dirname(fn)
    fnbase = basename(fn).rsplit('.h5')[0]
    fnmeasure = join(fnpath, prefix + fnbase + '.h5')

    existed = os.path.isfile(fnmeasure)
    fm = h5files.open(fnmeasure, 'a')

    if not existed:
        fm.attrs['TYPE'] = 'MEASUREMENT'
        fm.attrs['SOURCE'] = str(fn)
        fm['source'] = h5py.ExternalLink(fn, '/')
    return fm
Example #24
0
def plotSingleRun(fn):
    out = splitext(basename(fn))[0]
    f = h5files.open(fn, 'r')
    rc = matplotlib.rc
    rc('figure', figsize=(7, 7), dpi=100)
    rc('font', size=8.)
    rc('axes', titlesize=10., labelsize=10.)
    rc('pdf', compression=6, fonttype=42)
    rc(
        'figure', **{
            'subplot.left': 0.02,
            'subplot.right': 1. - 0.05,
            'subplot.bottom': 0.01,
            'subplot.top': 1. - 0.05,
            'subplot.wspace': 0.1,
            'subplot.hspace': 0.1
        })
    #rc('savefig', facecolor='none', edgecolor='none', dpi=100)
    rc('savefig', dpi=100)
    rc('font', **{'family': 'sans-serif'})  #,'sans-serif':['Helvetica']})
    rc('path', simplify_threshold=0.01)
    #rc('text', usetex=True, **{ 'latex.unicode' : True })

    with mpl_utils.PdfWriter(out + ".pdf") as pdfpages:
        dataman = myutils.DataManager(100, [
            DataTumorTissueSingle(),
            DataTumorMeasureCurvature(),
            DataTumor3dRendering(),
            DataTissueRadial(),
            DataTissueRadialAveraged()
        ])
        resultfile = ResultFile(f, dataman)
        is3d = resultfile.obtain_data('ld').shape[2] > 1
        if is3d:
            plot3dRendering(resultfile,
                            pdfpages,
                            showVessels=True,
                            showTumor=False)
            plot3dRendering(resultfile, pdfpages)
            plot3dRendering(resultfile, pdfpages, showVessels=True)
        plotSnapshots(resultfile, pdfpages)
def worker_on_client(vessel_fn, tumor_parameters, o2_parameter_set_name,
                     num_threads):
    krebsutils.set_num_threads(num_threads)
    tumor_fn = tumor_parameters['fn_out']
    tend = tumor_parameters['tend']
    pattern1 = 'out0000'
    pattern2 = 'out%04i' % int(round(tend / tumor_parameters['out_intervall']))
    pattern = '|'.join([pattern1, pattern2])
    print tumor_fn, pattern
    #os.system("%s -s '%s'" %  (krebsjobs.submitTumOnlyVessels.exe,dicttoinfo(tumor_parameters)))
    os.system("%s -s '%s'" %
              (krebs.tumors.run_faketum, dicttoinfo(tumor_parameters)))
    o2_refs = detailedo2.doit(
        tumor_fn, pattern,
        (getattr(krebs.detailedo2Analysis.parameterSetsO2,
                 o2_parameter_set_name), o2_parameter_set_name))
    for ref in o2_refs:
        po2group = h5files.open(ref.fn)[ref.path]
        krebs.analyzeTissueOxygenDetailed.WriteSamplesToDisk(po2group)
    krebs.povrayRenderOxygenDetailed.doit(o2_refs[1].fn, o2_refs[1].path)
    h5files.closeall()
def createParamFile(files, label):
  writepath = '/localdisk/thierry/tmp/%s_parms.py' % label
  #mode = 'a' if os.path.exists(writepath) else 'w'
  mode = 'w'
  if os.path.exists(writepath):
    os.remove(writepath)
  with open(writepath,mode) as f:
    f.write('# -*- coding: utf-8 -*-\n')
    for t in typelist:
      for pso_file in files:
        if t in pso_file:
          f_opt_data = h5files.open(pso_file, 'r', search = False)
          xopt = f_opt_data.attrs.get('xopt')
          f.write('pso_param_%s_%s_vary1=deepcopy(adaption_master)\n' % (label,t))
          f.write('pso_param_%s_%s_vary1[\'adaption\'].update(\n' % (label,t))
          f.write('  k_m = %f,\n' % xopt[0])
          f.write('  k_c = %f,\n' % xopt[1])
          f.write('  k_s = %f,\n' % xopt[2])
          f.write('  cond_length = %f,\n' % xopt[3])
          f.write('  Q_refdot = %f,\n' % xopt[4])
          f.write(')\n')
  print("Created file: %s"%writepath)
def ProduceData(fitParameters, filename): 
  from krebs.analyzeGeneral import   DataBasicVessel, DataVesselSamples, DataVesselGlobal
  from krebs.detailedo2Analysis import DataDetailedPO2
  import krebs.detailedo2Analysis.singleVesselCases as singleVesselCases

  paramspo2Override = dict(
    massTransferCoefficientModelNumber = 1,
    conductivity_coeff1 = fitParameters[0],
    conductivity_coeff2 = fitParameters[1],
    conductivity_coeff3 = fitParameters[2],
  )

  f = h5files.open(filename,'a')

  krebsutils.set_num_threads(2)
  dataman = myutils.DataManager(20, [DataDetailedPO2(),DataBasicVessel(), DataVesselSamples(), DataVesselGlobal()])

  for k, params in fitCases:
    params = deepcopy(params)
    params.paramspo2.update(paramspo2Override)
    singleVesselCases.GenerateSingleCapillaryWPo2(dataman, f, k, 16, params)
  return f
                                      distancemap_spec)
            plot_data(ax, ranges, mvd.avg * 1e6, mvd.std * 1e6, 'rg'[j],
                      't = %i h' % time)
            lim = ax.get_ylim()
            ax.vlines(ranges[1:-1], lim[0], lim[1])
            #ax.set(ylim = lim, xlim = (ax.get_xlim()[0], 1000))
            ax.set(xlabel=r'distance from rim [$\mu m$]',
                   ylabel=r'mvd [1/mm$^2$]')
            ax.legend()

        pdfpages.savefig(fig)


if __name__ == '__main__':
    filenames = sys.argv[1:]
    files = [h5files.open(fn, 'r') for fn in filenames]
    fmeasure = h5files.open('analyzeBloodVolumeMeasurements.h5', 'a')
    dataman = myutils.DataManager(10, [
        DataTumorTissueSingle(),
        DataVesselRadial(),
        DataVesselSamples(),
        DataBasicVessel(),
        DataDistanceFromCenter()
    ])

    #allgroups = sorted(filter(lambda k: k.startswith('out'), files[0].keys()))
    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])
Example #29
0
    parser.add_option(
        "--write-flow",
        dest="write_flow",
        help=
        "writes the recomputed flow; note: hematocrit is completely ignored!",
        default=False,
        action="store_true")
    options, args = parser.parse_args()
    if options.write_flow:
        options.force_flow_recompute = True

    dataman = myutils.DataManager(100, [DataBasicVessel()])

    filenames, pattern = args[:-1], args[-1]
    files = [
        h5files.open(fn, 'a' if options.add_resistor_bc else 'r+')
        for fn in filenames
    ]
    groups = list(
        itertools.chain.from_iterable(
            myutils.walkh5(f, pattern, return_h5objects=True) for f in files))

    for vesselgroup in groups:
        if options.force_flow_recompute and not options.add_resistor_bc:
            (pressure, flow,
             shearforce) = krebsutils.calc_vessel_hydrodynamics(vesselgroup)
            vessels = dataman.obtain_data('vessel_graph', vesselgroup,
                                          ['flags', 'radius'])
            vessels.edges['flow'] = flow
            vessels.nodes['pressure'] = pressure
        else:
Example #30
0
def DoIt(filenames, pattern, with_o2):
    fn_measure = basename(commonprefix(filenames))
    fn_measure = myutils.strip_from_end(fn_measure, '.h5')
    fn_measure = myutils.strip_from_end(fn_measure, '-type')

    def cachelocation(g):
        path = posixpath.join(
            'FileCS_' + myutils.checksum(basename(g.file.filename)),
            g.name.strip(posixpath.sep))
        return (f_measure, path)

    if with_o2:
        fn_measure = myutils.strip_from_end(fn_measure, '_detailedpo2')

    files = [h5files.open(fn, 'a') for fn in filenames]
    f_measure = h5files.open('plotVessels_chache.h5', 'a', search=False)
    groups = list(
        itertools.chain.from_iterable(
            myutils.walkh5(f, pattern, return_h5objects=True) for f in files))
    if len(groups) <= 0:
        print 'no matching groups in hdf file(s)'
        sys.exit(0)

    if with_o2:
        name = posixpath.commonprefix(map(lambda g: g.name, groups))
        name = myutils.strip_from_start(name, '/po2/vessels').replace('/', '-')
        fn_measure += name

    with mpl_utils.PdfWriter(fn_measure + '.pdf') as pdfpages:
        rc = matplotlib.rc
        rc('font', size=8.)
        rc('axes', titlesize=10., labelsize=8.)

        if with_o2:
            import detailedo2Analysis as o2analysis
            import detailedo2Analysis.plotsForPaper
            import detailedo2
            dataman = myutils.DataManager(20, [
                o2analysis.DataDetailedPO2(),
                analyzeGeneral.DataTumorTissueSingle(),
                analyzeGeneral.DataDistanceFromCenter(),
                analyzeGeneral.DataBasicVessel(),
                analyzeGeneral.DataVesselSamples(),
                analyzeBloodFlow.DataTumorBloodFlow(),
                analyzeGeneral.DataVesselRadial(),
                analyzeGeneral.DataVesselGlobal()
            ])

            vesselgroups = list(
                detailedo2.OpenVesselAndTumorGroups(g)[0] for g in groups)
            #original_vesselgroups = list(h5files.openLink(g, 'SOURCE') for g in vesselgroups)
            if 1:
                PrintGlobalDataWithOxygen(pdfpages, groups, vesselgroups,
                                          f_measure, dataman)
                '''FormatParameters makes the network creation parameters
            that does not work, if we have an o2 file'''
                #text = FormatParameters(original_vesselgroups[0].file)
                text = [' ']
                text += detailedo2Analysis.plotsForPaper.FormatParameters(
                    groups[0])
                fig, _ = mpl_utils.MakeTextPage(text,
                                                figsize=(mpl_utils.a4size[0],
                                                         mpl_utils.a4size[0]))
                pdfpages.savefig(fig, postfix='_vesselsparams')
            if 1:
                res = getMultiScatter(300. * len(filenames), vesselgroups)
                plotMultiScatterBeauty(res, pdfpages)

        else:
            dataman = myutils.DataManager(20, [
                analyzeGeneral.DataTumorTissueSingle(),
                analyzeGeneral.DataVesselRadial(),
                analyzeGeneral.DataDistanceFromCenter(),
                analyzeBloodFlow.DataTumorBloodFlow(),
                analyzeGeneral.DataBasicVessel(),
                analyzeGeneral.DataVesselSamples(),
                analyzeGeneral.DataVesselGlobal()
            ])
            #dataman = myutils.DataManager(20, [ analyzeGeneral.DataBasicVessel(), analyzeGeneral.DataVesselSamples(), analyzeGeneral.DataVesselGlobal()])
            vesselgroups = groups

            if 0:
                res = getMultiScatter(300. * len(filenames), vesselgroups)
                plotMultiScatterBeauty(res, pdfpages)
            if 0:
                PlotRadiusHistogram2(dataman, vesselgroups, pdfpages)

            if 0 and all(map(lambda g: 'data' in g.parent, vesselgroups)):
                data = VesselData()
                for g in vesselgroups:
                    data.add(g.parent['data'])
                plot_topological_stats_avg(data, pdfpages)
            if 0:  #reproduce swine
                plot_geometric_stuff_on_RC(dataman, f_measure, filenames,
                                           options, pdfpages)
            if 1:
                PrintGlobalData(pdfpages, vesselgroups, f_measure, dataman)