import pyWIMP.DMModels.wimp_model as wimp_model from pyWIMP.DMModels.base_model import BaseVariables import ROOT import re #ROOT.gROOT.SetBatch() basevars = BaseVariables(0, 1, 0, 3.5) time = basevars.get_time() time.setConstant() time.setVal(0) mass_of_wimp = 10 wm = wimp_model.WIMPModel(basevars, mass_of_wimp) c1 = ROOT.TCanvas() c1.SetLogy() #test = ROOT.MGMWimpHelmFFSquared("model", "model", q, r, s) #energy = q test = wm.get_helm_form_factor() test1 = wm.get_WIMP_model() test2 = wm.get_WIMP_model_with_escape_vel() test3 = wm.get_WIMP_model_with_escape_vel_no_ff() energy = basevars.get_energy() frame = energy.frame() energy.setVal(0) print test1.getVal(), test2.getVal(), test3.getVal(), test.getVal() variables = ROOT.RooArgSet(basevars.get_energy()) integral = test1.createIntegral(variables) orig = integral.getVal() integral = test.createIntegral(variables) ff_int = integral.getVal()
wimp_mass = float(sys.argv[1]) ##################################### """ Initialization stuff """ ##################################### ROOT.RooRandom.randomGenerator().SetSeed(0) ROOT.RooMsgService.instance().setSilentMode(True) ROOT.RooMsgService.instance().setGlobalKillBelow(5) total_mc_entries = 1000 #total_mc_entries = 10 total_entries = 400 exponential_total = 190 basevars = BaseVariables(0, 0.1444,0.5, 3.5) basevars.get_time().setConstant(True) # Set up the WIMP class wimp_class = WIMPModel(basevars, mass_of_wimp = wimp_mass, kilograms=0.4, constant_quenching=False) model = wimp_class.get_model() # Set up the background class background = TestModel(basevars) list_of_models, list_of_coefficients = \ background.get_list_components() exp_coef = list_of_coefficients.at(
def initialize(self): if self.is_initialized: return from pyWIMP.DMModels.wimp_model import WIMPModel from pyWIMP.DMModels.base_model import BaseVariables from pyWIMP.DMModels.flat_model import FlatModel self.total_counts = int(self.mass_of_detector* self.background_rate* (self.energy_max-self.threshold)* self.total_time*365) self.basevars = BaseVariables(time_beginning=0, time_in_years=self.total_time, energy_threshold=self.threshold, energy_max=self.energy_max) if self.num_energy_bins != 0: self.basevars.get_energy().setBins(int(self.num_energy_bins)) if self.num_time_bins != 0: self.basevars.get_time().setBins(int(self.num_time_bins)) self.variables = ROOT.RooArgSet() if self.constant_time: self.basevars.get_time().setVal(0) self.basevars.get_time().setConstant(True) else: self.variables.add(self.basevars.get_time()) if not self.constant_energy: self.variables.add(self.basevars.get_energy()) self.calculation_class = \ ec.ExclusionCalculation(self.exit_manager) # This is where we define our models self.backgroundClass = TritiumDecayModel(self.basevars, self.tritium_exposure_time, self.tritium_activation_rate, self.mass_of_detector, self.background_rate) # This model is already an extended model self.background_model = self.backgroundClass.get_model() self.background_extend = self.background_model if not self.do_axioelectric: # The following has not been normalized to per-nucleon yet. self.model_normal = ROOT.RooRealVar("model_normal", "WIMP-nucleus #sigma", 0, -1e-15, 0.1, 'pb') self.wimpClass = WIMPModel(self.basevars, mass_of_wimp=self.wimp_mass, kilograms = self.mass_of_detector, constant_quenching=(not self.variable_quenching)) self.model = self.wimpClass.get_model() self.norm = self.wimpClass.get_normalization().getVal() self.model_extend = ROOT.RooExtendPdf("model_extend", "model_extend", self.model, self.model_normal) else: # wimpClass is of course a misnomer here, but we use it for now self.wimpClass = GaussianSignalModel(self.basevars, mean_of_signal=self.axion_mass) self.model_normal = ROOT.RooRealVar("model_normal", "Counts", 0, -10, 1000) # This is where we define our model self.model = self.wimpClass.get_model() self.norm = self.wimpClass.get_normalization()*self.model.getNorm( ROOT.RooArgSet(self.basevars.get_energy())) # We actually want the inverse of the normaliation, since this is later multiplied # and we want the total counts in a particular gaussian. self.norm = 1./self.norm self.model_extend = ROOT.RooExtendPdf("model_extend", "model_extend", self.model, self.model_normal) self.added_pdf = ROOT.RooAddPdf("b+s", "Background + Signal", ROOT.RooArgList( self.background_extend, self.model_extend)) self.test_variable = self.model_normal self.data_set_model = self.background_extend self.fitting_model = self.added_pdf self.is_initialized = True
def initialize(self): if self.is_initialized: return from pyWIMP.DMModels.base_model import BaseVariables from pyWIMP.DMModels.flat_model import FlatModel from pyWIMP.DMModels.oscillation_model import OscillationModel self.basevars = BaseVariables(time_beginning=0, time_in_years=self.total_time, energy_threshold=self.threshold, energy_max=self.energy_max) self.oscClass = OscillationModel(self.basevars) self.flatClass = FlatModel(self.basevars) self.calculation_class = \ osc.OscillationSensitivityCalculation(self.exit_manager) self.variables = ROOT.RooArgSet() self.variables.add(self.basevars.get_time()) self.basevars.get_energy().setVal(0) self.basevars.get_energy().setConstant(True) # This is where we define our models self.background = self.flatClass.get_model() self.model = self.oscClass.get_model() self.norm = 1 self.is_initialized = True if self.model_amplitude > 1: self.model_amplitude = 1 elif self.model_amplitude < 0: self.model_amplitude = 0 self.signal_percentage = ROOT.RooRealVar("signal_percentage", "signal_percentage", self.model_amplitude) self.background_model = ROOT.RooAddPdf( "background", "Data Model", self.model, self.background, self.signal_percentage) self.model_normal = ROOT.RooRealVar("model_normal", "model_normal", self.model_amplitude, 0, 1) self.total_fit_counts = ROOT.RooRealVar("total_fit_counts", "total_fit_counts", self.total_counts, 0, 3*self.total_counts) self.added_pdf = ROOT.RooAddPdf( "added_pdf", "Fit Model", self.model, self.background, self.model_normal) self.model_extend = ROOT.RooExtendPdf("model_extend", "Signal + Background", self.added_pdf, self.total_fit_counts) self.test_variable = self.model_normal self.data_set_model = self.background_model self.fitting_model = self.model_extend
def initialize(self): # The background model is the same, but now we switch it to the data model from pyWIMP.DMModels.low_energy_background import LowEnergyBackgroundModel from pyWIMP.DMModels.base_model import BaseVariables from pyWIMP.DMModels.wimp_model import WIMPModel self.total_counts = None open_file = ROOT.TFile(self.data_file) self.workspace = open_file.Get(self.object_name) # Do some introspection, we can handle TH1s, and RooAbsData self.basevars = BaseVariables(time_beginning=0, time_in_years=self.total_time, energy_threshold=self.threshold, energy_max=self.energy_max, use_tag=False) self.variables = ROOT.RooArgSet() if self.workspace.InheritsFrom(ROOT.TH1.Class()): self.variables.add(self.basevars.get_energy()) self.basevars.get_time().setVal(0) self.basevars.get_time().setConstant(True) self.data_set_model = ROOT.RooDataHist("data", "data", ROOT.RooArgList(self.basevars.get_energy()), self.workspace) elif self.workspace.InheritsFrom(ROOT.TTree.Class()): # Default to setting them to constant. self.basevars.get_time().setVal(0) self.basevars.get_time().setConstant(True) self.basevars.get_energy().setVal(0) self.basevars.get_energy().setConstant(True) if self.num_energy_bins != 0: self.basevars.get_energy().setBins(int(self.num_energy_bins)) if self.num_time_bins != 0: self.basevars.get_time().setBins(int(self.num_time_bins)) branches = self.workspace.GetListOfBranches() efficiency = "" branch_arg_list = [] for i in range(branches.GetEntries()): branch_name = branches[i].GetName() if branch_name == "ee_energy": self.basevars.get_energy().setConstant(False) self.variables.add(self.basevars.get_energy()) branch_arg_list.append((self.basevars.get_energy(), branch_name)) if branch_name == "time": self.basevars.get_time().setConstant(False) self.variables.add(self.basevars.get_time()) branch_arg_list.append((self.basevars.get_time(), branch_name)) elif branch_name == "weight": efficiency = branch_name self.variables.add(self.basevars.get_weighting()) if not self.data_set_cuts: # Load the DataSet the easy way self.data_set_model = ROOT.RooDataSet("data", "data", self.workspace, self.variables, efficiency) else: # Otherwise, we have to get the correct events, # which requires stepping through all events self.data_set_model = ROOT.RooDataSet("data", "data", self.variables, efficiency) # Get an event list with the correct cut events ROOT.gROOT.cd() el = ROOT.TEventList("el", "el") cuts = self.data_set_cuts iter = self.variables.createIterator() while 1: obj = iter.Next() if not obj: break if obj.GetTitle() == 'weight': continue cuts += " && ((%s <= %f) && (%s >= %f))" % (obj.GetName(), obj.getMax(), obj.GetName(), obj.getMin()) self.workspace.Draw(">>%s" % el.GetName(), cuts, "goff") event_list = [el.GetEntry(i) for i in range(el.GetN())] #event_list = [i for i in range(self.workspace.GetEntries())] for j in event_list: self.workspace.GetEntry(j) eff_val = 1. if efficiency: eff_val = getattr(self.workspace, efficiency) for val in branch_arg_list: val[0].setVal(getattr(self.workspace, val[1])) if eff_val != 0: self.data_set_model.add(self.variables, eff_val) else: print "Requested: %s, isn't a TTree or TH1!" % self.data_set_name raise TypeError if self.num_energy_bins != 0 or self.num_time_bins != 0: self.original_data_set = self.data_set_model self.data_set_model = self.original_data_set.binnedClone() if self.data_set_model.isWeighted(): print "Data set is weighted" print "Data set has %i entries." % self.data_set_model.sumEntries() if not self.do_axioelectric: self.wimpClass = WIMPModel(self.basevars, mass_of_wimp=self.wimp_mass, kilograms = self.mass_of_detector, constant_quenching=(not self.variable_quenching)) # This is where we define our model self.model = self.wimpClass.get_model() #self.model = self.wimpClass.get_simple_model() self.norm = self.wimpClass.get_normalization().getVal() # The following has not been normalized to per-nucleon yet. self.model_normal = ROOT.RooRealVar("model_normal", "WIMP-nucleus #sigma", 1, -10, 100, "pb") self.model_extend = ROOT.RooExtendPdf("model_extend", "model_extend", self.model, self.model_normal) # Getting the number of events for a model_normal of 1 # This gives us number of events per model_normal value scaler = self.model_extend.expectedEvents(self.variables) self.model_normal.setMax(2*self.data_set_model.sumEntries()/scaler) else: # wimpClass is of course a misnomer here, but we use it for now self.wimpClass = GaussianSignalModel(self.basevars, mean_of_signal=self.axion_mass) self.model_normal = ROOT.RooRealVar("model_normal", "Counts", 0, -10, 1000) # This is where we define our model self.model = self.wimpClass.get_model() self.norm = self.wimpClass.get_normalization()*self.model.getNorm( ROOT.RooArgSet(self.basevars.get_energy())) # We actually want the inverse of the normaliation, since this is later multiplied # and we want the total counts in a particular gaussian. self.norm = 1./self.norm self.model_extend = ROOT.RooExtendPdf("model_extend", "model_extend", self.model, self.model_normal) self.is_initialized = True self.calculation_class = \ dat.DataCalculation(self.exit_manager) self.low_energy = LowEnergyBackgroundModel(self.basevars, use_ratio=self.fix_l_line_ratio) list_of_models, list_of_coefficients = self.low_energy.get_list_components() self.extended_models = [] i = 0 while 1: amod = list_of_models.at(i) avar = list_of_coefficients.at(i) if not amod: break i += 1 extend = ROOT.RooExtendPdf("extend%s" % amod.GetName(), "extend%s" % amod.GetName(), amod, avar) self.extended_models.append(extend) temp_list = ROOT.RooArgList() temp_list.add(self.model_extend) for amod in self.extended_models: temp_list.add(amod) self.added_pdf = ROOT.RooAddPdf("b+s", "Background + Signal", temp_list) self.test_variable = self.model_normal self.fitting_model = self.added_pdf
# Now string_np holds all the necessary values, with the first value being the best fit ##################################### """ Initialization stuff """ ##################################### ROOT.RooRandom.randomGenerator().SetSeed(0) ROOT.RooMsgService.instance().setSilentMode(True) ROOT.RooMsgService.instance().setGlobalKillBelow(5) total_mc_entries = 500 total_mc_entries = 400 basevars = BaseVariables(0, 0.14887063655, 0.5, 3.5) basevars.get_time().setConstant(True) # Set up the WIMP class wimp_class = WIMPModel(basevars, mass_of_wimp=wimp_mass, kilograms=0.4, constant_quenching=False) model = wimp_class.get_model() normalization = wimp_class.get_normalization().getVal() # Set up the background class low_energy = LowEnergyBackgroundModel(basevars) low_energy_model = low_energy.get_model() list_of_models, list_of_coefficients = low_energy.get_list_components() background_normal = ROOT.RooRealVar("flat_normal", "Background event number",
#!/usr/bin/env python from pyWIMP.DMModels.base_model import BaseVariables import pyWIMP.DMModels.wimp_model as wimp_model import ROOT import re mass_of_wimp = 7 basevars = BaseVariables(0.0, 4.0, 0, 10, True, 0.0) time = basevars.get_time() time.setConstant() time.setVal(0) wm = wimp_model.WIMPModel(basevars, mass_of_wimp, nucl_recoil=True) model = wm.get_WIMP_model() expected_events = model.expectedEvents(ROOT.RooArgSet(basevars.get_energy())) hist = model.createHistogram("hist", basevars.get_energy(), \ ROOT.RooFit.Binning(200),\ ROOT.RooFit.YVar(basevars.get_time(), \ ROOT.RooFit.Binning(4*36))) hist.SetLineColor(4) hist.GetXaxis().CenterTitle() hist.GetXaxis().SetTitle("Energy (keVnr)") hist.GetXaxis().SetTitleOffset(1.5) hist.GetYaxis().CenterTitle() hist.GetYaxis().SetTitle("Time (years)") hist.GetYaxis().SetTitleOffset(1.5) hist.GetYaxis().SetNdivisions(507) hist.GetZaxis().CenterTitle() hist.GetZaxis().SetTitle("Amplitude (a.u.)") hist.GetZaxis().SetTitle("#frac{dR}{dE} #sigma^{-1} (counts/keV/kg/yr/pb)") hist.GetZaxis().SetTitleOffset(1.1) hist.GetZaxis().SetNdivisions(509)