Пример #1
0
    def runTest(self):
        try:
            # instantiate the class

            a = admit.Project(self.admitdir)

            #use a GenerateSpectrum_AT that reads in a spectrum
            gs1 = a.addtask(
                admit.GenerateSpectrum_AT(file=self.specfile,
                                          freq=124.470,
                                          seed=-1))
            gstab1 = (gs1, 0)

            # instantiate a LineSegment AT and set parameters
            l = admit.LineSegment_AT()
            task1id = a.addtask(l, [gstab1])
            a.fm.verify()
            a.run()
            # read in the admit.xml and bdp files
            a2 = admit.Project(self.admitdir)
            self.success = "OK"
        except Exception, e:
            m = "exception=%s, file=%s, lineno=%s" % (
                sys.exc_info()[0].__name__,
                os.path.basename(
                    sys.exc_info()[2].tb_frame.f_code.co_filename),
                sys.exc_info()[2].tb_lineno)
            self.success = "FAILED"
            traceback.print_exc()
            self.fail("%s failed with: %s" % (self.__class__.__name__, m))
Пример #2
0
    def runTest(self):
        print "####  %s ####" % self.testName
        try:
            for i in range(len(self.transitions)):
                spec = self.a.addtask(
                    admit.GenerateSpectrum_AT(seed=self.seed[i],
                                              nchan=self.nchan[i],
                                              contin=self.contin[i],
                                              delta=self.delta[i],
                                              freq=self.freq[i],
                                              transitions=self.transitions[i],
                                              alias="test_%i" % (i)))
                bdp_in = [(spec, 0)]
                csub = [1, 1]
                segment = "ADMIT"
                numsigma = 2.0
                minchan = 5
                maxgap = 3
                vlsr = 0.0

                linesegment1 = self.a.addtask(
                    admit.LineSegment_AT(segment=segment, csub=csub), bdp_in)
                self.a[linesegment1].setkey('numsigma', numsigma)
                self.a[linesegment1].setkey('minchan', minchan)
                self.a[linesegment1].setkey('maxgap', maxgap)

                lineid1 = self.a.addtask(
                    admit.LineID_AT(vlsr=vlsr, segment=segment, csub=csub),
                    bdp_in)
                self.a[lineid1].setkey('numsigma', numsigma)
                self.a[lineid1].setkey('minchan', minchan)
                self.a[lineid1].setkey('maxgap', maxgap)
                self.a[lineid1].setkey('identifylines', False)

                print "################## RUNNING TRANSITION %d: %s ######################### " % (
                    i, self.transitions[i][0][0])

                self.a.run()

                segtable = self.a.fm[linesegment1]._bdp_out[0].table
                linetable = self.a.fm[lineid1]._bdp_out[0].table
                number_of_segments = len(segtable)
                number_of_lines = len(linetable)
                self.assertEqual(
                    number_of_segments,
                    number_of_lines,
                    msg=
                    "Number of Line Segments doesn't match number of LineIDs")

                for rowindex in range(min(number_of_segments,
                                          number_of_lines)):
                    rowS = segtable.getRowAsDict(rowindex)
                    rowL = linetable.getRowAsDict(rowindex)
                    self.assertEqual(
                        rowS, rowL,
                        "Values for row %d of segment table and line table do not match"
                        % rowindex)
            self.success = "OK"
        except Exception, e:
            m = "exception=%s, file=%s, lineno=%s" % (
                sys.exc_info()[0].__name__,
                os.path.basename(
                    sys.exc_info()[2].tb_frame.f_code.co_filename),
                sys.exc_info()[2].tb_lineno)
            self.success = "FAILED"
            traceback.print_exc()
            self.fail("%s failed with: %s" % (self.__class__.__name__, m))
Пример #3
0
admit.util.utils.rmdir(projdir)

a = admit.Project(projdir,
                  name='Testing LineID',
                  create=True,
                  loglevel=loglevel)

# Default ADMIT plotting environment
a.plotparams(plotmode, plottype)

for i in range(len(transitions)):
    spec = a.addtask(
        admit.GenerateSpectrum_AT(seed=seed[i],
                                  nchan=nchan[i],
                                  contin=contin[i],
                                  delta=delta[i],
                                  freq=freq[i],
                                  transitions=transitions[i],
                                  alias="test_%i" % (i)))
    bdp_in = [(spec, 0)]

    lineid1 = a.addtask(
        admit.LineID_AT(vlsr=0.0, segment="ADMIT", csub=[1, 1]), bdp_in)
    a[lineid1].setkey('numsigma', 2.0)
    a[lineid1].setkey('minchan', 5)
    a[lineid1].setkey('maxgap', 3)  # 20 for the SB outflows
    print "################## RUNNING TRANSITION %d ######################### " % i

    # keep run() inside loop so that failures won't
    # prevent us seeing output from previous tasks in the flow
    a.run()
Пример #4
0
else:
    print "All done, we just read an existing admit.xml and it should do nothing"
    print "Use admit0.py to re-run inside of your admit directory"
    #
    a.fm.diagram(a.dir()+'admit.dot')
    a.show()
    a.showsetkey()
    sys.exit(0)      # doesn't work in IPython!

# Default ADMIT plotting environment
a.plotparams(plotmode,plottype)

# GenerateSpectrum
# here we use a little backdoor in GenerateSpectrum_AT that reads in
# a spectrum 
gs1 = a.addtask(admit.GenerateSpectrum_AT(file=file,seed=-1,alias=alias))
gstab1 = (gs1,0)

if stop == 'generate':  a.exit(1)

# LineSegment
ls1 = a.addtask(admit.LineSegment_AT(),[gstab1])
if len(linepar) > 0:
    a[ls1].setkey('numsigma',linepar[0])
    a[ls1].setkey('minchan', linepar[1])
    a[ls1].setkey('maxgap',  linepar[2])
a[ls1].setkey('csub',[0,csub])
a[ls1].setkey('iterate',iterate)
a[ls1].setkey('smooth',llsmooth)
lstab1 = (ls1,0)