def analyse(obsname, bkgname, srcmodel, spec, pars, alphas=[1.0]): """ Analyse observations Parameters ---------- obsname : str Observation definition XML file bkgname : str Background model definition XML file srcmodels : list of str List of source models spec : str Spectral model pars : dict Dictionary of analysis parameters alphas : list of float, optional List of template map scaling factors """ # Handle map if srcmodel == 'map': # Loop over alphas for alpha in alphas: # Load observations _obsname = set_observation(obsname, srcmodel, bkgname, pars, alpha=alpha) obs = gammalib.GObservations(_obsname) # Set analysis analysis = set_analysis(srcmodel, bkgname, spec, pars, alpha=alpha) # Fit model fit(obs, srcmodel, spec, bkgname, analysis, pars, alpha=alpha) # Determine Npred npred(obs, analysis, pars) # Handle other models else: # Load observations _obsname = set_observation(obsname, srcmodel, bkgname, pars, alpha=1.0) obs = gammalib.GObservations(_obsname) # Set analysis analysis = set_analysis(srcmodel, bkgname, spec, pars, alpha=1.0) # Fit model fit(obs, srcmodel, spec, bkgname, analysis, pars, alpha=1.0) # Determine Npred npred(obs, analysis, pars) # Return return
def get_obs_results(obsname, resname): """ Get observation results Parameters ---------- obsname : str Observation definition XML file resname : str Model result XML file """ # Initialise results results = [] # Load observations and models inobs = gammalib.GObservations(obsname) models = gammalib.GModels(resname) # Loop over runs in observations for run in inobs: # Build observation container with single run obs = gammalib.GObservations() obs.append(run) # Get background model has_model = False for model in models: if model.classname() == 'GCTAModelBackground' and model.is_valid('HESS', run.id()): has_model = True break # Fall through if we have no model if not has_model: continue # Set results result = {'id': run.id(), 'ontime': run.ontime(), 'livetime': run.livetime(), 'deadc': run.deadc(), 'ra': run.pointing().dir().ra_deg(), 'dec': run.pointing().dir().dec_deg(), 'zenith': run.pointing().zenith(), 'azimuth': run.pointing().azimuth(), 'detx': model.spatial()[1].value(), 'e_detx': model.spatial()[1].error(), 'dety': model.spatial()[2].value(), 'e_dety': model.spatial()[2].error()} # Append results results.append(result) # Return return results
def plot_phases(filename, plotfile, nphases=40): """ Plot phases Parameters ---------- filename : str Name of lightcurve FITS file plotfile : str Plot file name """ # Read observation container. If an exception occurs then try loading the # file as an event list and build an observation container. try: obs = gammalib.GObservations(filename) except: obs = gammalib.GObservations() obs.append(gammalib.GCTAObservation(filename)) # Initialise phases phases = [] # Loop over all observations for run in obs: # Get events events = run.events() # Loop over all events for event in events: # Get phase phase = event.phase() # Collect phase phases.append(phase) phases.append(phase + 1.0) # Plot phase plt.figure() plt.hist(phases, bins=nphases, range=(0.0, 2.0), facecolor='r') plt.xlabel('Phase') plt.ylabel('Events') # Show figure if len(plotfile) > 0: plt.savefig(plotfile) else: plt.show() # Return return
def selection_run(self, input_obs_list, output_obs_list, tmin=0, tmax=None, energy=[None, None], prefix='selected_', log_file='ctselect.log', force=False, save=False): if tmin < 0 or tmax < 1 or tmin >= tmax: raise Exception("ctselect needs better tmin/tmax") select = ctools.ctselect() if isinstance(input_obs_list, gammalib.GObservations): select.obs(input_obs_list) elif os.path.isfile(input_obs_list): # observations list from file select["inobs"] = input_obs_list else: raise Exception('Cannot understand input obs list for csphagen') select["rad"] = "INDEF" select["ra"] = "INDEF" select["dec"] = "INDEF" select["tmin"] = tmin select["tmax"] = tmax select["emin"] = energy[0] if energy[0] else "INDEF" select["emax"] = energy[1] if energy[1] else "INDEF" select["prefix"] = prefix select["outobs"] = output_obs_list select["logfile"] = log_file if force or not os.path.isfile(output_obs_list): select.logFileOpen() select.run() elif os.path.isfile(output_obs_list): basename, ext = os.path.splitext(output_obs_list) if ext == '.xml': select = ctools.ctselect( gammalib.GObservations(output_obs_list)) else: # .fits container = gammalib.GObservations() gcta_obs = gammalib.GCTAObservation(output_obs_list) container.append(gcta_obs) select.obs(container) else: raise Exception("Cannot proceed with ctselect") saved = False if (save and force) or (save and not os.path.isfile(output_obs_list)): select.save() # why it doesn't save anytime? saved = True logger.info("Files {} created.".format(output_obs_list)) return select
def get_onoff_info(on_off_obs_file): obs = gammalib.GObservations(on_off_obs_file) onoff_obs = obs[0] # GCTAOnOffObservation # Pulse Height Analyzer class. # This class implements a Pulse Height Analyzer (PHA) spectrum that is used # as data container for an XSPEC analysis. A PHA spectrum is a vector that # provides the number of measured counts as function of the channel number. pha_on = onoff_obs.on_spec() pha_off = onoff_obs.off_spec() spectrum_bins = pha_on.size() if spectrum_bins != 1: print( "spectrum bins are more then expected. Need to change something in code to manage them" ) on_count = pha_on.counts() off_count = pha_off.counts() alpha_val = pha_on.backscal(spectrum_bins - 1) # index 0 = spectrum_bins -1 li_ma_val = li_ma(on_count, off_count, alpha_val) return { "N_on": on_count, "N_off": off_count, "N_s": (on_count - alpha_val * off_count), "alpha": alpha_val, "li_ma": li_ma_val, }
def __init__(self, *argv): """ Constructor. Parameters ---------- argv : list of str List of IRAF command line parameter strings of the form ``parameter=3``. """ # Set name and version self._name = 'csobsdef' self._version = '1.1.0' # Initialise class members self._obs = gammalib.GObservations() self._pntdef = gammalib.GCsv() self._tmin = 0.0 # Initialise application by calling the appropriate class # constructor. self._init_cscript(argv) # Return return
def simulate_ctobssim(obs, xmlname, seed=0): """ Simulate events using ctobssim. """ # Create containers observations = gammalib.GObservations() observations.append(obs) # Append models models = gammalib.GModels(xmlname) observations.models(models) print(models[0]) # Allocate ctobssim application and set parameters sim = ctools.ctobssim(observations) sim['seed'].integer(seed) # Run simulator sim.run() # Retrieve events events = sim.obs()[0].events().copy() # Print event statistics npred = obs.npred(models) print(str(len(events)) + " events simulated.") print(str(npred) + " events expected from Npred.") # Delete the simulation del sim # Return events return events
def __init__(self, *argv): """ Constructor. """ # Set name self._name = "cstsdist" self._version = "1.1.0" # Initialise some members self._obs = gammalib.GObservations() self._pattern = "single" self._srcname = "" self._enumbins = 0 self._npix = 0 self._binsz = 0.0 self._outfile = gammalib.GFilename("ts.dat") self._ntrials = 10 self._edisp = False self._debug = False self._log_clients = False # Initialise application by calling the appropriate class # constructor. self._init_cscript(argv) # Return return
def survey_single(): """ Creates a single observation survey for test purposes. """ # Allocate observation container obs = gammalib.GObservations() # Set single pointing at galactic centre pntdir = gammalib.GSkyDir() pntdir.lb_deg(0.0, 0.0) run = obsutils.set_obs(pntdir) obs.append(run) # Define single point source with Crab flux at galactic centre center = gammalib.GSkyDir() center.lb_deg(0.0, 0.0) point_spatial = gammalib.GModelSpatialPointSource(center) point_spectrum = crab_spec() point = gammalib.GModelSky(point_spatial, point_spectrum) point.name('GC source') # Create model container models = gammalib.GModels() models.append(point) obs.models(models) # Return observation container return obs
def generate_background_lookup(): """ Generate background lookup from empty field observations """ # Set filenames obsname = '$HESSDATA/obs/obs_off.xml' filename = 'off_lookup.fits' # Continue only if lookup table does not yet exist if not os.path.isfile(filename): # Initialise lookup table emin = gammalib.GEnergy(0.2, 'TeV') emax = gammalib.GEnergy(50.0, 'TeV') ebds = gammalib.GEbounds(10, emin, emax) lookup = gammalib.GCTAModelSpatialLookup(2.0, 0.2, ebds) # Load empty field observations obs = gammalib.GObservations(obsname) # Fill lookup table lookup.fill(obs) # Save lookup table lookup.save(filename, True) # Return return
def _generate_runwise_bkg(self): """ Generate background models """ # Loop over observations for run in self.obs(): # Write header self._log_header2(gammalib.TERSE, self._get_obs_header(run)) # Build observation container with single run obs = gammalib.GObservations() obs.append(run) # Generate background model for model = self._generate_bkg(obs) # Set model attributes model.name(('Background_%s' % run.id())) model.ids(run.id()) # Write model self._log_string(gammalib.NORMAL, str(model)) # Append background model self._models.append(model) # Return return
def _check_obsdef_file(self, filename): """ Check observation definition file """ # Load observation definition file obs = gammalib.GObservations(filename) # Check number of observations self.test_value( obs.size(), 3, 'Check for 3 observations in observation definition file') # Loop over all observations for o in obs: self.test_value(o.instrument(), 'CTA', 'Check for "CTA" instrument') self.test_value(o.ontime(), 1800.0, 1.0e-6, 'Check for ontime of 1800 sec') self.test_value(o.deadc(), 0.95, 1.0e-6, 'Check for deadtime correction of 0.95') self.test_value(o.events().ebounds().emin().TeV(), 0.1, 1.0e-6, 'Check for minimum energy of 0.1 TeV') self.test_value(o.events().ebounds().emax().TeV(), 100.0, 1.0e-6, 'Check for maximum energy of 100 TeV') self.test_value(o.roi().radius(), 5.0, 1.0e-6, 'Check for ROI radois of 5 deg') # Return return
def _get_parameters(self): """ Get parameters from parfile """ # Initialise observation container if it is currently empty if self.obs().size() == 0: # If an observation definition file was provided then load it, # otherwise build a single observation with response information if self['inobs'].is_valid(): self.obs(gammalib.GObservations(self['inobs'].filename())) else: cta = gammalib.GCTAObservation() caldb = gammalib.GCaldb('cta', self['caldb'].string()) rsp = gammalib.GCTAResponseIrf(self['irf'].string(), caldb) cta.response(rsp) self.obs().append(cta) # Query input parameters self['emin'].real() self['emax'].real() self['aeffthres'].real() self['bkgthres'].real() # Query ahead output model filename if self._read_ahead(): self['outfile'].filename() # Write input parameters into logger self._log_parameters(gammalib.TERSE) # Return return
def generate_background_lookup(obslist=None, suffix=''): """ Generate background lookup from empty field observations Parameters ---------- obslist : list of int, optional Indices of observations to use suffix : str, optional Background lookup file suffix """ # Set filenames obsname = '$HESSDATA/obs/obs_off.xml' filename = 'bkg_lookup%s.fits' % suffix # Continue only if lookup table does not yet exist if not os.path.isfile(filename): # Initialise lookup table emin = gammalib.GEnergy(0.2, 'TeV') emax = gammalib.GEnergy(50.0, 'TeV') ebds = gammalib.GEbounds(10, emin, emax) lookup = gammalib.GCTAModelSpatialLookup(2.0, 0.2, ebds) # Load empty field observations obs = gammalib.GObservations(obsname) # If an observation list was specified then exclude observations # in list if obslist != None: newobs = gammalib.GObservations() for i, run in enumerate(obs): if i not in obslist: newobs.append(run) else: print('Exclude %s' % (run.id())) obs = newobs print('%d observations in lookup table' % (len(obs))) # Fill lookup table lookup.fill(obs) # Save lookup table lookup.save(filename, True) # Return return
def analyse(obsname, bkgname, srcmodel, spec, pars, select=None, fitname='pks_results', npredname='pks_npred'): """ Analyse observations Parameters ---------- obsname : str Observation definition XML file bkgname : str Background model definition XML file srcmodel : str Source model spec : str Spectral model pars : dict Dictionary of analysis parameters select : list of int, optional Indices for observation selection fitname : str, optional Fit result prefix npredname : str, optional Npred result prefix """ # Load observations _obsname = set_observation(obsname, srcmodel, bkgname, pars) obs = gammalib.GObservations(_obsname) # Optionally select observations if select != None: obs_select = gammalib.GObservations() for i in select: obs_select.append(obs[i]) obs = obs_select # Set analysis analysis = set_analysis(srcmodel, bkgname, spec, pars, select=select) # Fit model fit(obs, srcmodel, spec, bkgname, analysis, pars, fitname=fitname) # Determine Npred npred(obs, analysis, pars, fitname=fitname, npredname=npredname) # Return return
def _set_obs(self, lpnt=0.0, bpnt=0.0, emin=0.1, emax=100.0): """ Set an observation container. Kwargs: lpnt: Galactic longitude of pointing [deg] (default: 0.0) bpnt: Galactic latitude of pointing [deg] (default: 0.0) emin: Minimum energy [TeV] (default: 0.1) emax: Maximum energy [TeV] (default: 100.0) Returns: Observation container. """ # If an observation was provided on input then load it from XML # file filename = self["inobs"].filename() if filename != "NONE" and filename != "": obs = self._get_observations() # ... otherwise allocate a single observation else: # Read relevant user parameters caldb = self["caldb"].string() irf = self["irf"].string() deadc = self["deadc"].real() duration = self["duration"].real() rad = self["rad"].real() # Allocate observation container obs = gammalib.GObservations() # Set single pointing pntdir = gammalib.GSkyDir() pntdir.lb_deg(lpnt, bpnt) # Create CTA observation run = obsutils.set_obs(pntdir, caldb=caldb, irf=irf, duration=duration, deadc=deadc, emin=emin, emax=emax, rad=rad) # Append observation to container obs.append(run) # Set source position offset = self["offset"].real() pntdir.lb_deg(lpnt, bpnt + offset) self._ra = pntdir.ra_deg() self._dec = pntdir.dec_deg() # Return observation container return obs
def _masked_cube(self, cube, ra, dec, rad, emin='INDEF', emax='INDEF', regfile='NONE'): """ Mask an event cube and returns the masked cube Parameters ---------- cube : `~gammalib.GCTAEventCube` Event cube ra : float (str 'INDEF' for no selection on direction) Right Ascension (deg) dec : float (str 'INDEF' for no selection on direction) Declination (deg) rad : float (str 'INDEF' for no selection on direction) Radius (deg) emin : float (str 'INDEF' for no selection on energy) Minimum energy (TeV) emax : float (str 'INDEF' for no selection on energy) Maximum energy (TeV) Returns ------- cube : `~gammalib.GCTAEventCube` Event cube """ # Turn cube into observation container to feed to ctcubemask obs = gammalib.GCTAObservation() obs.events(cube) obs_cont = gammalib.GObservations() obs_cont.append(obs) # Use ctcubemask to mask event cube pixels cubemask = ctools.ctcubemask(obs_cont) cubemask['ra'] = ra cubemask['dec'] = dec cubemask['rad'] = rad cubemask['emin'] = emin cubemask['emax'] = emax cubemask['regfile'] = regfile cubemask.run() # Extract copy of cube from observation container (copy is needed to # avoid memory leaks in SWIG) cube = cubemask.obs()[0].events().copy() # Return cube return cube
def _check_outobs(self, filenameroot, nout): """ Check the output XML file containing ON/OFF observations """ # Load observation container obs = gammalib.GObservations(filenameroot) # Check container size self.test_value(obs.size(), nout, 'Check for ' + str(nout) + ' observations in XML file') # Return return
def _check_observation_file(self, filename, number): """ Check observation definition file """ # Open observations obs = gammalib.GObservations(filename) # Check number of models self.test_value( obs.size(), number, 'Check for ' + str(number) + ' observations in XML file') # Return return
def __init__(self, *argv): """ Constructor """ # Initialise application by calling the base class constructor self._init_cscript(self.__class__.__name__, ctools.__version__, argv) # Initialise some members self._obs = gammalib.GObservations() self._ebounds = gammalib.GEbounds() self._datapath = os.getenv('VHEFITS', '') self._prodname = '' self._xml = gammalib.GXml() self._models = gammalib.GModels() self._runlist = [] self._runlistfile = gammalib.GFilename() self._bkgpars = 0 self._master_indx = '' self._use_bkg_scale = False self._ev_hiera = [''] self._aeff_hiera = [''] self._psf_hiera = [''] self._bkg_hiera = [''] self._edisp_hiera = [''] self._bkg_mod_hiera = [''] self._bkg_gauss_norm = 1.0 self._bkg_gauss_index = 0.0 self._bkg_gauss_sigma = 1.0 self._bkg_aeff_index = 0.0 self._bkg_aeff_norm = 1.0 self._bkg_range_factor = 1.0 self._hdu_index = '' self._obs_index = '' self._subdir = '' self._debug = False # Initialise empty observation definition XML file self._xml.append( gammalib.GXmlElement('observation_list ' 'title="observation list"')) # Append an observation list to XML instance self._xml.append( gammalib.GXmlElement('observation_list title="observation list"')) self._xml_obslist = self._xml.element('observation_list', 0) # Return return
def obs(self): """ Returns GObservations object """ # Initialise observations obs = gammalib.GObservations() # Read observations if XML is filled if self._xml.size(): obs.read(self._xml) # Assign models obs.models(self._models) # Return observations return obs
def open_observation(self, obsfilename): print('Open observation') obs = gammalib.GObservations() self.obsconf = ObservationConfiguration(obsfilename, self.runconf.timesys, self.runconf.timeunit, self.runconf.skyframeref, self.runconf.skyframeunitref) print(self.obsconf.caldb) pntdir = gammalib.GSkyDir() in_pnttype = self.obsconf.point_frame print(in_pnttype) if in_pnttype == 'fk5': pntdir.radec_deg(self.obsconf.point_ra, self.obsconf.point_dec) #if in_pnttype == 'equatorial' : #pntdir.radec_deg(self.obs_ra, self.obs_dec) #if in_pnttype == 'galactic' : # pntdir.radec_deg(self.in_l, self.in_b) #pntdir.radec_deg(self.obsconf.obs_point_ra, self.obsconf.obs_point_dec) tstart = self.obsconf.tstart - self.runconf.timeref print(tstart) if self.runconf.timeref_timesys == 'mjd': tstart = tstart * 86400. print("TSTART " + str(tstart)) obs1 = obsutils.set_obs(pntdir, tstart, self.obsconf.duration, 1.0, \ self.obsconf.emin, self.obsconf.emax, self.obsconf.roi_fov, \ self.obsconf.irf, self.obsconf.caldb, self.obsconf.id) print(obs1) obs.append(obs1) #print(obs1) return obs
def _check_obsdef(self, filename, obs_expected): """ Check observation definition XML file """ # Load observation definition XML file obs = gammalib.GObservations(filename) # Check number of observations self.test_value( obs.size(), obs_expected, 'Check for ' + str(obs_expected) + ' observations in XML file') # If there are observations in the XML file then check their content if obs_expected > 0: # Get response rsp = obs[0].response() # Test response self.test_value(obs[0].eventfile().file(), 'events_0.fits.gz', 'Check event file name') self.test_value(obs[0].eventfile().extname(), 'EVENTS', 'Check event extension name') self.test_value(rsp.aeff().filename().file(), 'irf_file.fits.gz', 'Check effective area file name') self.test_value(rsp.aeff().filename().extname(), 'EFFECTIVE AREA', 'Check effective area extension name') self.test_value(rsp.psf().filename().file(), 'irf_file.fits.gz', 'Check point spread function file name') self.test_value(rsp.psf().filename().extname(), 'POINT SPREAD FUNCTION', 'Check point spread function extension name') self.test_value(rsp.edisp().filename().file(), 'irf_file.fits.gz', 'Check energy dispersion file name') self.test_value(rsp.edisp().filename().extname(), 'ENERGY DISPERSION', 'Check energy dispersion extension name') self.test_value(rsp.background().filename().file(), 'irf_file.fits.gz', 'Check background file name') self.test_value(rsp.background().filename().extname(), 'BACKGROUND', 'Check background extension name') # Return return
def create_lightcurve_gti(obsname, gtiname): """ Generate lightcurve for GTIs Parameters ---------- obsname : str Observation definition XML file gtiname : str GTI output filename """ # Load observations obs = gammalib.GObservations(obsname) # Initialize GTIs gti = gammalib.GGti() # Loop over observations for run in obs: # Get start time and ontime of GTIs tstart = run.gti().tstart().copy() ontime = run.gti().ontime() # Set time bins tbin = ontime / 14.0 # Loop over time bins for i in range(14): # Compute stop time tstop = tstart + tbin # Append GTI gti.append(tstart, tstop) # Update start time tstart = tstop.copy() # Save GTIs gti.save(gtiname, True) # Return return
def _setup_sim(self, two=False): """ Setup method for sim() function test """ # Set-up observation container pnt = gammalib.GSkyDir() pnt.radec_deg(83.6331, 22.0145) obs = gammalib.GObservations() run = obsutils.set_obs(pnt, duration=20.0, emin=1.0, emax=10.0) run.id('0') obs.append(run) if two: run.id('1') obs.append(run) # Append model obs.models(gammalib.GModels(self._model)) # Return return obs
def run_multi_ctobssim(RA, DEC, TSTART, DURATION, DEADC, EMIN, EMAX, RAD, IRF, CALDB, outfile, nobs): """TODO: document what it does""" observations = gammalib.GObservations() # Automatically generate a number of nobs for i in xrange(nobs): obs = set(RA, DEC, TSTART, DURATION, DEADC, EMIN, EMAX, RAD, IRF, CALDB) obs.id(str(i)) observations.append(obs) observations.models('$CTOOLS/share/models/crab.xml') ctobssim = ctools.ctobssim(observations) ctobssim.logFileOpen() ctobssim['outfile'].filename(outfile) ctobssim.execute()
def __init__(self, *argv): """ Constructor Parameters ---------- argv : list of str List of IRAF command line parameter strings of the form ``parameter=3``. """ # Initialise application by calling the base class constructor self._init_cscript(self.__class__.__name__, ctools.__version__, argv) # Initialise class members self._obs = gammalib.GObservations() self._pntdef = gammalib.GCsv() self._tmin = 0.0 # Return return
def simulation_run(self, model_file, events_file, ra=None, dec=None, time=[0, 1800], energy=[None, None], log_file='ctobssim.log', force=False, save=False): sim = ctools.ctobssim() sim["inmodel"] = model_file sim["outevents"] = events_file sim["seed"] = self.seed sim["ra"] = ra if ra else self.ra sim["dec"] = dec if dec else self.dec sim["rad"] = self.rad sim["tmin"] = float(time[0]) sim["tmax"] = float(time[1]) sim["emin"] = energy[0] if energy[0] else self.energy_min sim["emax"] = energy[1] if energy[1] else self.energy_max sim["caldb"] = self.caldb sim["irf"] = self.irf sim["logfile"] = log_file sim["nthreads"] = self.nthreads if force or not os.path.isfile(events_file): sim.logFileOpen() sim.run() else: container = gammalib.GObservations() gcta_obs = gammalib.GCTAObservation(events_file) container.append(gcta_obs) sim.obs(container) sim.obs().models(gammalib.GModels(model_file)) saved = False if (save and force) or (save and not os.path.isfile(events_file)): sim.save() saved = True logger.info("Events file '{}' saved. time [{}-{}]".format( sim["outevents"].value(), time[0], time[1])) return sim
def plot_obs_zeniths(ax, obsname, color, srcname, y0=-0.015): """ Plot observation results Parameters ---------- ax : pyplot Subplot obsname : str Observation definition XML file color : str Color string srcname : str Source name y0 : float, optional Vertical axis location of lower edge of bar """ # Get zenith angle range zenith_min = 90.0 zenith_max = 0.0 obs = gammalib.GObservations(obsname) for run in obs: zenith = run.pointing().zenith() if zenith < zenith_min: zenith_min = zenith if zenith > zenith_max: zenith_max = zenith # Plot filled rectangle x0 = zenith_min width = zenith_max - zenith_min height = 0.006 ax.add_patch(Rectangle((x0,y0), width, height, alpha=1, facecolor=color)) ax.text(x0+0.5*width,y0+0.5*height, srcname, fontsize=7, horizontalalignment='center', verticalalignment='center') # Return return
def _test_python(self): """ Test csobs2caldb from Python """ # Set-up csobs2caldb using "inobs" parameter irf = cscripts.csobs2caldb() irf['inobs'] = self._inobs irf['caldb'] = 'cta' irf['irf'] = 'Py1' irf['rootdir'] = 'caldb' irf['logfile'] = 'csobs2caldb_py1.log' irf['chatter'] = 2 # Run csobs2caldb script and save IRF irf.logFileOpen() # Make sure we get a log file irf.run() irf.save() # Check response self._check_response('cta', 'Py1') # Load observation container obs = gammalib.GObservations(self._inobs) # Set-up csobs2caldb using observation container irf = cscripts.csobs2caldb(obs) irf['caldb'] = 'cta' irf['irf'] = 'Py2' irf['rootdir'] = 'caldb' irf['logfile'] = 'csobs2caldb_py2.log' irf['chatter'] = 3 # Execute csobs2caldb script irf.execute() # Check response self._check_response('cta', 'Py2') # Return return