f(Λ)

ROOT examples

Mon, 30 Jan 2017 13:00:00 +0100

make_binned_and_fitted_to_root.C

#include "TFile.h"
#include "TGraphErrors.h"
#include "TCanvas.h"
#include "TAxis.h"
//g++ `root-config --libs --cflags --ldflags` make_graph.C -o make_graph
//.x ./make_binned_and_fitted_to_root.C("binned_and_fitted_channel_signal_1_channel_trigger_2_pulse_length_3.csv", "graphs.root", "title", "x_name", "y_name")
#include "Riostream.h"
using namespace std;
 
void make_binned_and_fitted_to_root(TString csv_file, TString root_file, TString Graph_Name="", TString x_name="", TString y_name=""){
   ifstream in;
   in.open(csv_file);
   TFile *f = new TFile(root_file, "UPDATE");
   TGraphErrors *g1 = new TGraphErrors();
   TCanvas *c1 = new TCanvas(Graph_Name);
   Double_t dac, A, mu, sigma;
   Int_t point = 0;
 
 while(1){
       in>>dac>>A>>mu>>sigma;
       point++;
       if (!in.good()){
           break;
       }
       g1->Set(point);
       g1->SetPoint(point, dac, mu);
       g1->SetPointError(point, 50, sigma);
   }
   c1->cd();
   g1->SetTitle(Graph_Name);
   g1->GetXaxis()->SetTitle(x_name);
   g1->GetYaxis()->SetTitle(y_name);
   g1->Draw("ap");
   f->cd();
   c1->Write();
   f->Close();
   delete f;
   delete c1;
   delete g1;
}
 
int main(int argc, char **argv){
   switch(argc){
       case 3:
           make_binned_and_fitted_to_root(argv[1], argv[2]);
           break;
       case 4: 
           make_binned_and_fitted_to_root(argv[1], argv[2], argv[3]);
           break;
       case 5:
           make_binned_and_fitted_to_root(argv[1], argv[2], argv[3],argv[4]);
           break;
       case 6:
           make_binned_and_fitted_to_root(argv[1], argv[2], argv[3],argv[4],argv[5]);
           break;
       default:
           return 1;
   }
   return 0;
}

make_graph.C

#include "TFile.h"
#include "TGraph.h"
#include "TCanvas.h"
#include "TAxis.h"
//g++ `root-config --libs --cflags --ldflags` make_graph.C -o make_graph
#include "Riostream.h"
using namespace std;
 
void make_graph(TString csv_file, TString root_file, TString Graph_Name="", TString x_name="", TString y_name=""){
   ifstream in;
   in.open(csv_file);
   TFile *f = new TFile(root_file, "UPDATE");
   TGraph *g1 = new TGraph();
   TCanvas *c1 = new TCanvas(Graph_Name);
   Double_t x, y;
   Int_t point = 0;
 
 while(1){
       in>>x>>y;
       point++;
       if (!in.good()){
           break;
       }
       g1->Set(point);
       g1->SetPoint(point, x, y);
   }
   c1->cd();
   g1->SetTitle(Graph_Name);
   g1->GetXaxis()->SetTitle(x_name);
   g1->GetYaxis()->SetTitle(y_name);
   g1->Draw("ap");
   f->cd();
   c1->Write();
   f->Close();
}
 
int main(int argc, char **argv){
   switch(argc){
       case 3:
           make_graph(argv[1], argv[2]);
           break;
       case 4: 
           make_graph(argv[1], argv[2], argv[3]);
           break;
       case 5:
           make_graph(argv[1], argv[2], argv[3],argv[4]);
           break;
       case 6:
           make_graph(argv[1], argv[2], argv[3],argv[4],argv[5]);
           break;
       default:
           return 1;
   }
   return 0;
}

Copy zip file to a tar file

Mon, 30 Jan 2017 12:00:00 +0100

Snippet:

import io
import tarfile
import zipfile
 
def string2tar(name, bString):
        tmpfile = io.BytesIO(bString)
        tarinfo = tarfile.TarInfo(name=name)
        tarinfo.size=len(bString)
        return (tarinfo, tmpfile)
 
def convert_zip_to_tar(zipname, tarname):
        with zipfile.ZipFile(zipname) as zip_file, tarfile.open(tarname, "w|xz") as tar_file:
                for zip_file_name in zip_file.namelist():
                        content = zip_file.read(zip_file_name)
                        tar_file.addfile(*string2tar(zip_file_name, content))

Agilent Waveform generator and Oscilloscope example

Mon, 30 Jan 2017 12:00:00 +0100

Snippet:

__author__ = 'Frederik Lauber'
 
import visa
import zipfile
 
 
class hp_infinium(object):
    known_types = ("Type:", "Points:", "Count:", "XInc:", "XOrg:", "XRef:", "YData range:", "YData center:",
                   "Coupling:", "XRange:", "XOffset:", "YRange:", "YOffset:", "Date:", "Time:", "Frame:",
                   "Acq mode:", "Completion:", "X Units:", "Y Units:", "Max bandwidth:", "Min bandwidth:")
    known_set = set(known_types)
 
    # not checked yet, only from spec
    type_spec = {"1": "raw",
                 "2": "average",
                 "3": "vhistogram",
                 "4": "hhistogramm",
                 "5": "versus",
                 "6": "interpolation",
                 "8": "cgrade",
                 "10": "pdetect"
                 }
 
    # only number 3 was not tested, no idea how
    coupling_spec = {"0": "AC",
                     "1": "DC",
                     "2": "50 Ohms",
                     "3": "LFREJECT"
                     }
 
    # not checked yet, only from spec
    acq_spec = {"0": "real time",
                "1": "ETIMe",
                "3": "PDETect"
                }
 
    # not checked yet, only from spec
    xy_units_spec = {"0": "unknown",
                     "1": "Volt",
                     "2": "second",
                     "3": "constant",
                     "4": "amp",
                     "5": "decibel"
                     }
 
    @classmethod
    def from_gpig_name(cls, gpib_identifier_string, timeout):
        re = visa.ResourceManager()
        gpib_connection = re.get_instrument(gpib_identifier_string)
        return cls(gpib_connection, timeout)
 
    def __init__(self, gpib_connection, timeout):
        self._gpib_connection = gpib_connection
        self._timeout = None
        # variable used by the .timeout setter/getter method
        self.timeout = timeout
        self.write = self._gpib_connection.write
        self.ask = self._gpib_connection.ask
 
    @property
    def timeout(self):
        return self._timeout
 
    @timeout.setter
    def timeout(self, new_timeout):
        self._timeout = new_timeout
        if not new_timeout is None:
            self._gpib_connection.timeout = new_timeout
        else:
            del self._gpib_connection.timeout
 
    @property
    def idn(self):
        return self.ask("*IDN?")
 
    def digitize(self):
        # deletes the data on the scope and arms it again
        # self.write("Digitize")
        self.write(":DIGitize")
 
    def arm_trigger(self):
        answer = self.ask("*TRG;*OPC?")
        return True if answer == "1" else False
 
    def trigger_armed(self):
        return self.ask("AER?").strip()
 
    def preample(self):
        header = self.ask(":WAVeform:PREamble?").split(",")
        tmp = {}
        # this are the headers I found in the original csv files
        # if I did not have a value I used the one from the spec
        # if you  find a difference to the once produced by the oszi directly
        # please notify me
        tmp["Type:"] = self.type_spec[header[1]].strip()
        tmp["Points:"] = header[2].strip()
        tmp["Count:"] = header[3].strip()
        tmp["XInc:"] = header[4].strip()
        tmp["XOrg:"] = header[5].strip()
        tmp["XRef:"] = header[6].strip()
        tmp["YData range:"] = header[7].strip()
        tmp["YData center:"] = header[8].strip()
        # header[9] not used, spec says always 0
        tmp["Coupling:"] = self.coupling_spec[header[10]].strip()
        tmp["XRange:"] = header[11].strip()
        tmp["XOffset:"] = header[12].strip()
        tmp["YRange:"] = header[13].strip()
        tmp["YOffset:"] = header[14].strip()
        tmp["Date:"] = header[15].strip('"')
        tmp["Time:"] = header[16].strip('"')
        tmp["Frame:"] = header[17].strip('"')
        tmp["Acq mode:"] = self.acq_spec[header[19]].strip()
        tmp["Completion:"] = header[20].strip()
        tmp["X Units:"] = self.xy_units_spec[header[21]].strip()
        tmp["Y Units:"] = self.xy_units_spec[header[22]].strip()
        tmp["Max bandwidth:"] = header[23].strip()
        tmp["Min bandwidth:"] = header[24].strip()
        # adding header so we always know which one
        # was taken by the program
        tmp["GPIB:"] = "YES"
        return tmp
 
    def data(self, header):
        y = self.ask(":WAVeform:DATA?").split(",")
        xorig = float(header["XOrg:"])
        xinc = float(header["XInc:"])
        x_data = tuple(xorig + i * xinc for i in range(len(y)))
        y_data = tuple(float(i) for i in y)
        return x_data, y_data
 
    def make_csv_like_string(self, preample, data):
        output = []
        preample_keys = set(preample.keys())
        # first, add known keys
        # second add unknown keys
        # -> order will be the same as in the csv files generated by oszi
        # known headers
        for key in self.known_types:
            # Schema is:
            # Keyname+white space until length 15 and actual value
            try:
                output.append("".join([key, (15 - len(key)) * " ", str(preample[key])]))
            except Exception:
                pass
        for key in preample_keys.difference(self.known_set):
            output.append("".join([key, (15 - len(key)) * " ", str(preample[key])]))
        output.append("Data:")
 
        x_data = data[0]
        y_data = data[1]
        # for x, y in zip(x_data, y_data):
        for i in range(len(x_data)):
            output.append("%E,%E" % (x_data[i], y_data[i]))
        return "\n".join(output)
 
 
class Agilent_Waveform_Generator:
    def __init__(self, gpib_connection, timeout):
        self._gpib_connection = gpib_connection
        self._timeout = None
        # variable used by the .timeout setter/getter method
        self.timeout = timeout
        # add some shortcuts for gpib
        self.write = self._gpib_connection.write
        self.ask = self._gpib_connection.ask
 
    @classmethod
    def from_gpig_name(cls, gpib_identifier_string, timeout):
        re = visa.ResourceManager()
        gpib_connection = re.get_instrument(gpib_identifier_string)
        return cls(gpib_connection, timeout)
 
    @property
    def timeout(self):
        return self._timeout
 
    @timeout.setter
    def timeout(self, new_timeout):
        self._timeout = new_timeout
        if not new_timeout is None:
            self._gpib_connection.timeout = new_timeout
        else:
            del self._gpib_connection.timeout
 
    @property
    def idn(self):
        return self.ask("*IDN?")
 
    def trigger(self):
        self.write("*TRG")
 
    def trigger_wait(self):
        self.write("*TRG;*WAI")
 
    @property
    def trigger_source(self):
        return self.ask("TRIG:SOUR?").strip()
 
    @trigger_source.setter
    def trigger_source(self, value):
        self.write("TRIG:SOUR " + str(value))
 
    @property
    def burst_mode(self):
        return self.ask("BURS:MODE?").strip()
 
    @burst_mode.setter
    def burst_mode(self, value):
        # allowed TRIG, GAT
        self.write("BURS:MODE " + str(value))
 
    @property
    def function(self):
        return self.ask("FUNC?").strip()
 
    @function.setter
    def function(self, value):
        # allowed values are:
        # SIN, SQU, RAMP, PULS, NOIS, DC, USER
        self.write("FUNC " + str(value))
 
    @property
    def frequency(self):
        return float(self.ask("FREQ?"))
 
    @frequency.setter
    def frequency(self, value):
        # allowed: MIN, MAX, floating point number
        self.write("FREQ " + str(value))
 
    @property
    def voltage(self):
        return float(self.ask("VOLT?"))
 
    @voltage.setter
    def voltage(self, value):
        # allowed: MIN, MAX, floating point number
        self.write("VOLT " + str(value))
 
    @property
    def voltage_high(self):
        return float(self.ask("VOLT:HIGH?"))
 
    @voltage_high.setter
    def voltage_high(self, value):
        self.write("VOLT:HIGH " + str(value))
 
    @property
    def voltage_low(self):
        return float(self.ask("VOLT:LOW?"))
 
    @voltage_low.setter
    def voltage_low(self, value):
        self.write("VOLT:LOW " + str(value))
 
    @property
    def pulse_width(self):
        return float(self.ask("PULS:WIDT?"))
 
    @pulse_width.setter
    def pulse_width(self, value):
        # MIN, MAX, floating point in seconds
        self.write("PULS:WIDT " + str(value))
 
    @property
    def pulse_period(self):
        return float(self.ask("PULS:PER?"))
 
    @pulse_period.setter
    def pulse_period(self, value):
        # MIN, MAX, floating point in seconds
        self.write("PULS:PER " + str(value))
 
    @property
    def pulse_transition(self):
        return float(self.ask("PULS:TRAN?"))
 
    @pulse_transition.setter
    def pulse_transition(self, value):
        # MIN, MAX, floating point in seconds
        self.write("PULS:TRAN " + str(value))
 
    @property
    def burst_count(self):
        return float(self.ask("BURS:NCYC?"))
 
    @burst_count.setter
    def burst_count(self, value):
        # MIN, MAX, floating point in seconds
        self.write("BURS:NCYC " + str(value))
 
    @property
    def burst_phase(self):
        return float(self.ask("BURS:PHAS?"))
 
    @burst_phase.setter
    def burst_phase(self, value):
        # MIN, MAX, floating point in seconds
        self.write("BURS:PHAS " + str(value))
 
    @property
    def output(self):
        return False if self.ask("OUTP?").strip() == '0' else True
 
    @output.setter
    def output(self, value):
        # True, False
        if value:
            self.write("OUTP ON")
        else:
            self.write("OUTP OFF")
 
    @property
    def output_load(self):
        return float(self.ask("OUTP:LOAD?"))
 
    @output_load.setter
    def output_load(self, value):
        # INF, MIN, MAX, flaoting point in Ohms
        self.write("OUTP:LOAD " + str(value))
 
    @property
    def output_trigger(self):
        return False if self.ask("OUTP:TRIG?").strip() == '0' else True
 
    @output_trigger.setter
    def output_trigger(self, value):
        # True, False
        if value:
            self.write("OUTP:TRIG ON")
        else:
            self.write("OUTP:TRIG OFF")
 
    @property
    def output_trigger_slope(self):
        return self.ask("OUTP:TRIG:SLOP?").strip()
 
    @output_trigger_slope.setter
    def output_trigger_slope(self, value):
        # POS, NEG
        self.write("OUTP:TRIG:SLOP " + str(value))
 
    def enable_burst_mode(self):
        self.write("BURS:STAT ON")
 
    def clear_buffer(self):
        self.write("CLEAR 710")
 
    def clear_registers(self):
        self.write("*CLS")
 
 
def list_all_devices():
    re = visa.ResourceManager()
    device_list = re.list_resources()
    instrument_list = tuple(map(re.get_instrument, device_list))
    for instrument in instrument_list:
        idn = instrument.ask("*IDN?")
        print(idn)
    return instrument_list
 
 
#always set the waveform generator to the same settings
def setup_WFG(WFG):
    WFG.output = False
    WFG.output_load = 50
    WFG.output_trigger = True
    WFG.output_trigger_slope = "POS"
    WFG.function = "PULS"
    WFG.pulse_width = 1E-07
    WFG.pulse_period = 2E-07
    WFG.pulse_transition = 5E-09
    WFG.voltage_high = 2.5
    WFG.voltage_low = 0
    WFG.burst_mode = "TRIG"
    WFG.burst_count = 1
    WFG.burst_phase = 0
    WFG.trigger_source = "BUS"
 
    if not WFG.function == "PULS" \
            or not WFG.output_load == 50 \
            or not WFG.output_trigger is True \
            or not WFG.output_trigger_slope == "POS" \
            or not WFG.voltage_high == 2.5 \
            or not WFG.voltage_low == 0 \
            or not WFG.pulse_width == 1E-07 \
            or not WFG.burst_mode == "TRIG" \
            or not WFG.trigger_source == "BUS" \
            or not WFG.burst_count == 1:
        print("Setting for WFG failed failed")
        print(WFG.function == "PULS")
        print(WFG.output_load == 50)
        print(WFG.output_trigger is True)
        print(WFG.output_trigger_slope)
        print(WFG.voltage_high == 2.5)
        print(WFG.voltage_low == 0)
        print(WFG.pulse_width == 1E-07)
        print(WFG.burst_mode == "TRIG")
        print(WFG.trigger_source == "BUS")
        print(WFG.burst_count == 1)
        exit(1)
    WFG.output = True
    WFG.enable_burst_mode()
    print("WFG setup complete")
 
 
def main():
    instrument_list = list_all_devices()
    OSZI = hp_infinium(instrument_list[0], 10)
    WFG = Agilent_Waveform_Generator(instrument_list[1], 10)
    setup_WFG(WFG)
    #clear the the oscilloscope
    OSZI.write("DCL")
    OSZI.ask("ADER?")
    OSZI.ask("AER?")
    preample = OSZI.preample()
    with zipfile.ZipFile("test.zip", mode='w', compression=zipfile.ZIP_BZIP2) as file_zip:
        for counter in range(0, 6666, 1):
            print(counter)
            OSZI.arm_trigger()
            while not int(OSZI.trigger_armed):
                # wait for the arm register to be marked as armed
                pass
            WFG.trigger_wait()
            while not int(OSZI.ask("ADER?").strip()):
                # make sure we really get new data
                pass
            data = OSZI.data(preample)
            csv_string = OSZI.make_csv_like_string(preample, data)
            file_zip.writestr(str(counter).zfill(5) + ".csv", csv_string)
 
 
if __name__ == "__main__":
    main()

Similar picture finder

Thu, 26 Jan 2017 23:00:00 +0100

Snippets:

#!/usr/bin/env python
from __future__ import (absolute_import, division, print_function)
from PIL import Image, ImageFile
import sys
import os
import shutil
import errno
from imagehash import average_hash, phash, dhash, whash
import collections
import multiprocessing
import time
import math
import argparse
from argparse import RawTextHelpFormatter
ImageFile.LOAD_TRUNCATED_IMAGES = True
 
 
def ensure_folder(path):
   try:
       os.makedirs(path)
   except OSError as exception:
       if exception.errno != errno.EEXIST:
           raise
 
 
def image_ahash(image_path):
   try:
       with Image.open(image_path) as image:
           hash = average_hash(image)
   except Exception:
       return (image_path, None)
   return (image_path, hash)
 
def image_phash(image_path):
   try:
       with Image.open(image_path) as image:
           hash = phash(image)
   except Exception:
       return (image_path, None)
   return (image_path, hash)
 
def image_dhash(image_path):
   try:
       with Image.open(image_path) as image:
           hash = dhash(image)
   except Exception:
       return (image_path, None)
   return (image_path, hash)
 
def image_whash_haar(image_path):
   try:
       with Image.open(image_path) as image:
           hash = whash(image)
   except Exception:
       return (image_path, None)
   return (image_path, hash)
 
def image_whash_db4(image_path):
   try:
       with Image.open(image_path) as image:
           hash = whash(image, mode='db4')
   except Exception:
       return (image_path, None)
   return (image_path, hash)
 
def is_image(filename):
   f = filename.lower()
   return f.endswith(".png") or f.endswith(".jpg") or f.endswith(".jpeg") or f.endswith(".bmp") or f.endswith(".gif")
 
if __name__ == '__main__':
   parser = argparse.ArgumentParser(description='Find similar images in the input folder and move them to the output folder', formatter_class=RawTextHelpFormatter)
 
 hash_dict = { 'ahash': image_ahash, 
                 'phash': image_phash,
                 'dhash': image_dhash,
                 'whash-haar': image_whash_haar,
                 'whash-db4': image_whash_db4
   }
 
 help = """Method:
   ahash:  Average hash
   phash:  Perceptual hash
   dhash:  Difference hash
   whash-haar: Haar wavelet hash
   whash-db4:  Daubechies wavelet hash"""
 
 parser.add_argument("-hm", type=str,
                       choices = hash_dict.keys(),
                       default="ahash",
                       help = help
   )
 
 parser.add_argument('input_folder', type=str,
                       help='input folder')
   parser.add_argument('output_folder', type=str,
                       help='output folder')
 
 parser.add_argument("-now", type=int,
                       help='number of subproccesses for hashing', default=None)
 
   args = parser.parse_args()
 
   folder_in = os.path.abspath(args.input_folder)
  folder_out = os.path.abspath(args.output_folder)
  image_hashfunc = hash_dict[args.hm]
  poolsize = args.now
 
   if os.path.exists(folder_out):
      print("output folder exists!")
      print("Delete the folder before proceding")
      exit(1)
 
   print("Searching input folder:", folder_in)
  image_filenames = tuple([os.path.join(root, file) for root, dirs, files in os.walk(folder_in) for file in files if is_image(file)]) 
 
   total = len(image_filenames)
  print("Number of found images:", total)
 
   print("Hashing now...")
  images = collections.defaultdict(list)
  total = len(image_filenames)
  p = multiprocessing.Pool(poolsize)
  rs = p.imap_unordered(image_hashfunc, image_filenames, chunksize = 100)
  p.close()
 
   bar_length=50
  old = None
  for n, (image_path, hash) in enumerate(rs):
      images[hash].append(image_path)
      percents = round(100.0 * n / float(total), 1)
      if not percents == old:
          filled_len = int(round(bar_length * n / total))
          bar = '=' * filled_len + '-' * (bar_length - filled_len)
          sys.stdout.write('[%s] %s\r' % (bar, str(percents) + "%"))
          sys.stdout.flush()
      old = percents
  sys.stdout.write('[%s] %s' % ('=' * bar_length, "100%"))
  sys.stdout.flush()
 
 
    #are there any files which could not be hashed?
  if len(images[None]) > 0:
      print("")
      print("Problematic files:")
      for image in images[None]:
          print(image)
      del images[None]
 
 
    similar_files = 0
  for img_list in images.values():
      tmp = len(img_list)
      similar_files += 0 if tmp == 1 else tmp
 
   print("")
  if similar_files:
      print("Number of similar files:", similar_files)
      print("Moving to output folder")
      for k, img_list in images.items():
          if len(img_list) > 1:
              for img in img_list:
                  (path, _) = os.path.split(img)
                  to_folder = os.path.join(folder_out, path.split(":")[-1][1:])
                  ensure_folder(to_folder)
                  shutil.move(img, to_folder)
  else:
      print("No similar pictures found")
  print("All Done!")

Weighted Errors formulars

Mon, 19 Dec 2016 23:00:00 +0100

$$ \textrm{SEM} = \sqrt { \sum\limits_{i=0}^{N_b} w_i^2 - \frac{1}{N} \left( \sum\limits_{i=0}^{N_b} w_i \right)^2 } \\ \textrm{SD} = \sqrt{\frac{\sum\limits_{i=0}^N w_i \left(x_i - \bar{x}_w \right)^2}{\frac{\left( N_b - 1 \right) \sum\limits_{i=0}^{N} w_i }{N_b} }} \\ N - \textrm{Number of all data} \\ N_b - \textrm{Number of non 0 weights in bin}$$

IceCube: Template for a I3Tray module

Mon, 18 Jul 2016 13:00:00 +0200

Template for an I3Tray module in python.

class I3TrayModuleTemplate(icetray.I3ConditionalModule):
    def __init__(self,context):
        icetray.I3ConditionalModule.__init__(self, context)
        #self.AddParameter("opt1","Help message for parameter, parameter is required")
        #self.AddParameter("opt2","Help message for parameter, parameter is optional due to defaultValue","defaultValue")
 
    def Configure(self):
        #called once the module is added to the tray
        #self._opt1 = self.GetParameter("opt1")
        #self._opt2 = self.GetParameter("opt2")
        pass
 
    def Physics(self,frame):
        #function executed for P-frames
        #If frame is not pushed, other module will not see the frame
        #you can aso push multiple frames
        #self.PushFrame(frame) # to push frame
        pass
 
    def DAQ(self,frame):
        #same as the Physics function but for Q-frames
        pass
 
    def Finish(self):
        #called once the last frame is propagated to this module
        pass

Beta<->Gamma

Fri, 15 Jul 2016 13:00:00 +0200

As I always have to calculate beta vs gamma in the contect onf relativity theory, I just put these here.

Have fun!

$$\beta = \sqrt{1- \left(\frac{1}{\gamma} \right)^2}$$ $$\gamma = \frac{1}{\sqrt{1- \beta^2}}$$

IceCube: Enabling Cherenkov and luminescence light at the same time in ppc

Wed, 08 Jun 2016 11:00:00 +0200

Previous status in monopole ppc branch

direct and indirect Cherenkov light can be calculated
luminescence light can be calculated
but not both, enabling luminescence disables Cherenkov calculations

Goal

enable both at the same time at minimal code change

Idea

introduce a new parameter p_l (probability of luminescence light) for each photon
once the photon is processed, decide via dice roll if it was Cherenkov or lumiescence light
not the most elegant solution but requires the smallest change to currenct code
for future, maybe introduce a photon type enum with "direct Cherenkov, indirect Cherenkov, luminescence" and pass that to the particle. This way, we can either load specialised code for each case as the cann process all luminnescence/cherenkov photons in one go instead of branching for every photon

Implementaton

add p_l parameter to photon structure (ini.cxx)
calculate the ratio of luminescence photons to all photons in the yield function (f2k.cxx)
remove the code which switches between Cherenkov and luminescence (f2k.cxx)
introduce a new parameter x_l (random probability) in pro.cu. This parameter is compared to p_l to define if we have a luminescence or a Cherenkov photon. As the position and the angle of radiation are calculated at two different locations, we need to store the parameter so both subroutines are run in sync (position Cherenkov $=>$ angle Cherenkov, position luminescence => angle luminescence)

Current Status

the changes are merged into the svn
checkout the same event with Cherenkov light on the left and Cherenkov + luminescence light on the right. For the luminescence part a time decay of 2000ns and an efficency of 2 photons/MeV was chosen. Video

Stateless download link protection

Sun, 01 May 2016 01:00:00 +0200

TODO

download.cgi

#!/usr/bin/env python3.4
# -*- coding: UTF-8 -*-
 
from Crypto.Cipher import AES
import hashlib
DOWNLOAD_TIMEOUT_S = 30
DOWNLOAD_DIR = "~/downloads/"
PASSWORD = "SWORDFISH".encode("utf-8")
import cgi
#import cgitb; cgitb.enable()  # for troubleshooting
import os
import sys
import time
import urllib
from string import Template
from Crypto import Random
import binascii
 
 
class AESCipher(object):
   key =  hashlib.sha256(PASSWORD).digest()
   bs = AES.block_size
 
 def encrypt(self, number):
       string = str(number).zfill(len(str(number)) + self.bs - len(str(number)) % self.bs).encode("latin1")
       iv = Random.new().read(AES.block_size)
       cipher = AES.new(self.key, AES.MODE_CBC, iv)
       return binascii.hexlify(iv + cipher.encrypt(string))
 
 def decrypt(self, enc):
       string = binascii.unhexlify(enc)
       iv = string[:AES.block_size]
       enc = string[AES.block_size:]
       cipher = AES.new(self.key, AES.MODE_CBC, iv)
       string = cipher.decrypt(enc)
       return int(string)
 
test = ""
 
with open("./template/index.html", "rb") as file:
   template = file.read()
 
def read_tokken(url_tokken):
   try:
       aes = AESCipher()
       tokken_time = aes.decrypt(url_tokken)
   except Exception:
       return False
   now = int(time.time())
   return tokken_time > now - DOWNLOAD_TIMEOUT_S 
 
def gen_new_tokken():
   aes = AESCipher()
   return aes.encrypt(int(time.time())).decode("utf-8")
 
class file_desc:
   tokken = gen_new_tokken()#one tokken per side load
   row_template = Template("<tr><td><a href=\"?tokken=$tokken&file=$file\">$filename</td></tr>\n")
   def __init__(self, filepath, filename, description):
       self.filename = filename
       self.filepath = filepath
       #self.description = description
 
 def __str__(self):
       return self.row_template.substitute(tokken=urllib.parse.quote_plus(self.tokken), file=urllib.parse.quote_plus(self.filename), filename=self.filename)
 
 
class header:
   def __str__(self):
       return "<table>"
 
class fotter:
   def __str__(self):
       return "</table>\n"
 
def send_file(filename):
   filepath = os.path.join(DOWNLOAD_DIR, filename)
   size = os.path.getsize(filepath)
   sys.stdout.buffer.write(b'Cache-Control: no-cache, must-revalidate\n')
   sys.stdout.buffer.write(b'Pragma: no-cache\n')
   sys.stdout.buffer.write(b'Content-Length: ' + str(size).encode("ascii") + b'\n')
   sys.stdout.buffer.write(b'Content-Disposition: attachment; filename=' + filename.encode("ascii") + b'\n')
   sys.stdout.buffer.write(b'Content-Transfer-Encoding: binary\n')
   sys.stdout.buffer.write(b'Content-Type: application/octet-stream\n\n')
   with open(filepath , "rb" ) as download_file:
       while True:
           chunk = download_file.read(8192)
           if not chunk:
               break
           sys.stdout.buffer.write(chunk)
 
def display_page(message_list):
   global test
   sys.stdout.buffer.write(b"Content-type: text/html; charset=utf-8\n\n")
   tmp = ["<table>"]
   tmp.extend([str(obj) for obj in message_list])
   tmp.append("</table>")
   tmp.append(test)
   sys.stdout.buffer.write(template.replace(b"%%%youshouldnotseethis%%%", " ".join(tmp).encode("utf-8")))
 
 
 
def extract_params():
  global test
  form = cgi.FieldStorage(encoding="utf8")
  tokken = form.getvalue("tokken", "")
  file = form.getvalue("file", "")
  if file == "" or tokken == "":
      return False
  file = urllib.parse.unquote_plus(file)
  path = os.path.join(DOWNLOAD_DIR, file)
  if not os.path.exists(path):
      return False
  tokken = urllib.parse.unquote_plus(tokken)
  if read_tokken(tokken):
      return file
  else:
      return False
 
def directory_to_objlist(directory):
  files = os.listdir(directory)
  objlist = []
  for file in files:
      objlist.append(file_desc(file, file, " "))
  return objlist
 
 
file = extract_params()
if file:
  send_file(file)
else:
  display_page(directory_to_objlist(DOWNLOAD_DIR))

Heart function

Mon, 25 Apr 2016 23:20:00 +0200

Hello,

while going through my old University notes, I discovered this nice function.

A college of mine (hi Michael!) wanted to build a function which forms a heart and this is our result.

Obviously, a function cannot do this as you have multiple $y$-values for one $x$-value but combining two functions in two regimes, you can get close ( it is still missing that the first derivative must converge agains $\pm \infty$ for $x=\pm 1$).

$$\forall x \in \left[-1, 1\right], f^+\left(x\right) \rightarrow \Re^+, f^-\left(x\right) \rightarrow \Re^-\\ \color{red}{f^+\left( x \right)} = \sqrt{\left|x\right|-x^2} \\ \color{blue}{f^-\left(x\right)} = -\sqrt{1-\frac{1}{3} \cdot \left(x^2+2 \cdot \left|x\right| \right)}$$

Here is the result: