def __init__(self):
        PluginBase.__init__(self, name="Pr Inversion")
        ## Simulation window manager
        self.simview = None

        ## State data
        self.alpha = self.DEFAULT_ALPHA
        self.nfunc = self.DEFAULT_NFUNC
        self.max_length = self.DEFAULT_DMAX
        self.q_min = None
        self.q_max = None
        self.has_bck = False
        self.slit_height = 0
        self.slit_width = 0
        ## Remember last plottable processed
        self.last_data = ""
        self._current_file_data = None
        ## Time elapsed for last computation [sec]
        # Start with a good default
        self.elapsed = 0.022
        self.iq_data_shown = False

        ## Current invertor
        self.invertor = None
        self.pr = None
        self.data_id = IQ_DATA_LABEL
        # Copy of the last result in case we need to display it.
        self._last_pr = None
        self._last_out = None
        self._last_cov = None
        ## Calculation thread
        self.calc_thread = None
        ## Estimation thread
        self.estimation_thread = None
        ## Result panel
        self.control_panel = None
        ## Currently views plottable
        self.current_plottable = None
        ## Number of P(r) points to display on the output plot
        self._pr_npts = 51
        self._normalize_output = False
        self._scale_output_unity = False

        ## List of added P(r) plots
        self._added_plots = {}
        self._default_Iq = {}
        self.list_plot_id = []

        # Associate the inversion state reader with .prv files
        from inversion_state import Reader

        # Create a CanSAS/Pr reader
        self.state_reader = Reader(self.set_state)
        self._extensions = '.prv'
        l = Loader()
        l.associate_file_reader('.prv', self.state_reader)
        #l.associate_file_reader(".svs", self.state_reader)

        # Log startup
        logging.info("Pr(r) plug-in started")

 def test_double_trans_spectra(self):
     xmlreader = XMLreader(self.isis_1_1_doubletrans, self.schema_1_1)
     self.assertTrue(xmlreader.validate_xml())
     reader = Loader()
     data = reader.load(self.isis_1_1_doubletrans)
     for item in data:
         self._check_data(item)

    def get_panels(self, parent):
        """
        Create and return the list of wx.Panels for your plug-in.
        Define the plug-in perspective.

        Panels should inherit from DefaultPanel defined below,
        or should present the same interface. They must define
        "window_caption" and "window_name".

        :param parent: parent window

        :return: list of panels
        """
        # # Save a reference to the parent
        self.parent = parent
        self.frame = MDIFrame(self.parent, None, 'None', (100, 200))
        self.invariant_panel = InvariantPanel(parent=self.frame)
        self.frame.set_panel(self.invariant_panel)
        self._frame_set_helper()
        self.invariant_panel.set_manager(manager=self)
        self.perspective.append(self.invariant_panel.window_name)
        # Create reader when fitting panel are created
        self.state_reader = reader(self.set_state)
        # append that reader to list of available reader
        loader = Loader()
        loader.associate_file_reader(".inv", self.state_reader)
        # loader.associate_file_reader(".svs", self.state_reader)
        # Return the list of panels
        return [self.invariant_panel]

    def on_click_save(self, event):
        """
        Save change into a file
        """
        if not self._data:
            return
        self.on_change_run(event=None)
        self.on_change_title(event=None)
        path = None
        wildcard = "CanSAS 1D files(*.xml)|*.xml"
        dlg = wx.FileDialog(self, "Choose a file",
                            self._default_save_location, "", wildcard , wx.SAVE)

        for data in self._data:
            if issubclass(data.__class__, Data2D):
                msg = "No conventional writing format for \n\n"
                msg += "Data2D at this time.\n"
                dlg = wx.MessageDialog(None, msg, 'Error Loading File',
                                             wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
            else:
                if dlg.ShowModal() == wx.ID_OK:
                    path = dlg.GetPath()
                    mypath = os.path.basename(path)
                    loader = Loader()
                    format = ".xml"
                    if os.path.splitext(mypath)[1].lower() == format:
                        loader.save(path, data, format)
                    try:
                        self._default_save_location = os.path.dirname(path)
                    except:
                        pass
                    dlg.Destroy()
        event.Skip()

 def test_singleton(self):
     """
         Testing whether Loader is truly a singleton
     """
     # Create a 'new' Loader
     b = Loader()
     self.assertEqual(self.loader._get_registry_creation_time(),
                      b._get_registry_creation_time())

def load_data(filename):
    """
    Load data using a sasview loader.
    """
    from sas.sascalc.dataloader.loader import Loader
    loader = Loader()
    data = loader.load(filename)
    if data is None:
        raise IOError("Data %r could not be loaded" % filename)
    return data

class nxcansas_writer(unittest.TestCase):

    def setUp(self):
        self.loader = Loader()
        self.writer = NXcanSASWriter()
        self.read_file_1d = "cansas1d.xml"
        self.write_file_1d = "export1d.h5"
        self.read_file_2d = "exp18_14_igor_2dqxqy.dat"
        self.write_file_2d = "export2d.h5"

        self.data_1d = self.loader.load(self.read_file_1d)[0]

        self.data_2d = self.loader.load(self.read_file_2d)[0]
        self.data_2d.detector[0].name = ''
        self.data_2d.source.radiation = 'neutron'

    def test_write_1d(self):
        self.writer.write([self.data_1d], self.write_file_1d)
        data = self.loader.load(self.write_file_1d)
        self.assertTrue(len(data) == 1)
        data = data[0]
        self.assertTrue(len(data.x) == len(self.data_1d.x))
        self.assertTrue(len(data.y) == len(self.data_1d.y))
        self.assertTrue(len(data.dy) == len(self.data_1d.dy))
        self._check_metadata(data, self.data_1d)

    def test_write_2d(self):
        self.writer.write([self.data_2d], self.write_file_2d)
        data = self.loader.load(self.write_file_2d)
        self.assertTrue(len(data) == 1)
        data = data[0]
        self.assertTrue(len(data.data) == len(self.data_2d.data))
        self.assertTrue(len(data.qx_data) == len(self.data_2d.qx_data))
        self.assertTrue(len(data.qy_data) == len(self.data_2d.qy_data))
        self._check_metadata(data, self.data_2d)

    def _check_metadata(self, written, correct):
        self.assertTrue(written.title == correct.title)
        self.assertTrue(written.sample.name == correct.sample.name)
        self.assertAlmostEqual(written.sample.thickness, correct.sample.thickness)
        self.assertAlmostEqual(written.sample.temperature, correct.sample.temperature)
        self.assertTrue(written.instrument == correct.instrument)
        self.assertTrue(len(written.detector) == len(correct.detector))
        for i in range(len(written.detector)):
            written_det = written.detector[i]
            correct_det = correct.detector[i]
            self.assertAlmostEqual(written_det.distance, correct_det.distance)
            self.assertTrue(written_det.name == correct_det.name)
        self.assertTrue(written.source.radiation == correct.source.radiation)

    def tearDown(self):
        if os.path.isfile(self.write_file_1d):
            os.remove(self.write_file_1d)
        if os.path.isfile(self.write_file_2d):
            os.remove(self.write_file_2d)

 def test_old_cansas_files(self):
     reader1 = XMLreader(self.cansas1d, self.schema_1_0)
     self.assertTrue(reader1.validate_xml())
     file_loader = Loader()
     file_loader.load(self.cansas1d)
     reader2 = XMLreader(self.cansas1d_units, self.schema_1_0)
     self.assertTrue(reader2.validate_xml())
     reader3 = XMLreader(self.cansas1d_badunits, self.schema_1_0)
     self.assertTrue(reader3.validate_xml())
     reader4 = XMLreader(self.cansas1d_slit, self.schema_1_0)
     self.assertTrue(reader4.validate_xml())

class testLoader(unittest.TestCase):
    
    def setUp(self):
        self.L=Loader()
        self.L.find_plugins('../plugins')
            
    def testplugin(self):
        """ 
            test loading with a test reader only 
            found in the plugins directory
        """
        output = self.L.load('test_data.test')
        self.assertEqual(output.x[0], 1234.)

 def setUp(self):
     """
         Set up the initial conditions before _each_ test
         so that they all start from the same well-defined state. 
     """
     #Creating a loader
     self.L=Loader()

    def get_panels(self, parent):
        """
        Define the GUI panels
        """
        self.parent = parent
        self.frame = MDIFrame(self.parent, None, 'None', (100,200))
        self.data_id = IQ_DATA_LABEL
        self.corfunc_panel = CorfuncPanel(parent=self.frame)
        self.frame.set_panel(self.corfunc_panel)
        self.corfunc_panel.set_manager(self)
        self._frame_set_helper()
        self.perspective.append(self.corfunc_panel.window_name)

        l = Loader()
        l.associate_file_reader('.crf', self.state_reader)

        return [self.corfunc_panel]

    def choose_data_file(self, location=None):
        """
        Open a file dialog to allow loading a file
        """
        path = None
        if location == None:
            location = os.getcwd()

        l = Loader()
        cards = l.get_wildcards()
        wlist = '|'.join(cards)

        dlg = wx.FileDialog(self, "Choose a file", location, "", wlist, wx.OPEN)
        if dlg.ShowModal() == wx.ID_OK:
            path = dlg.GetPath()
            mypath = os.path.basename(path)
        dlg.Destroy()
        return path

 def setUp(self):
     self.loader = Loader()
     self.datafile_basic = find("simpleexamplefile.h5")
     self.datafile_multiplesasentry = find(
         "test_data" + os.sep + "nxcansas_1Dand2D_multisasentry.h5")
     self.datafile_multiplesasdata = find(
         "test_data" + os.sep + "nxcansas_1Dand2D_multisasdata.h5")
     self.datafile_multiplesasdata_multiplesasentry = find(
         "test_data" + os.sep + "nxcansas_1Dand2D_multisasentry_multisasdata.h5")

 def test_save_cansas_v1_0(self):
     filename = "isis_1_0_write_test.xml"
     xmlreader = XMLreader(self.isis_1_0, self.schema_1_0)
     valid = xmlreader.validate_xml()
     self.assertTrue(valid)
     reader_generic = Loader()
     dataloader = reader_generic.load(self.isis_1_0)
     reader_cansas = Reader()
     cansasreader = reader_cansas.read(self.isis_1_0)
     for i in range(len(dataloader)):
         self._check_data(dataloader[i])
         self._check_data(cansasreader[i])
         reader_generic.save(filename, dataloader[i], None)
         reader2 = Reader()
         return_data = reader2.read(filename)
         written_data = return_data[0]
         xmlwrite = XMLreader(filename, self.schema_1_0)
         valid = xmlreader.validate_xml()
         self.assertTrue(valid)
         self._check_data(written_data)

 def test_save_cansas_v1_0(self):
     xmlreader = XMLreader(self.isis_1_0, self.schema_1_0)
     self.assertTrue(xmlreader.validate_xml())
     reader_generic = Loader()
     dataloader = reader_generic.load(self.isis_1_0)
     reader_cansas = Reader()
     cansasreader = reader_cansas.read(self.isis_1_0)
     for i in range(len(dataloader)):
         self._check_data(dataloader[i])
         self._check_data(cansasreader[i])
         reader_generic.save(self.write_1_0_filename, dataloader[i], None)
         reader2 = Reader()
         self.assertTrue(os.path.isfile(self.write_1_0_filename))
         return_data = reader2.read(self.write_1_0_filename)
         written_data = return_data[0]
         xmlreader = XMLreader(self.write_1_0_filename, self.schema_1_0)
         self.assertTrue(xmlreader.validate_xml())
         self._check_data(written_data)
     if os.path.isfile(self.write_1_0_filename):
         os.remove(self.write_1_0_filename)

 def setUp(self):
     self.loader = Loader()
     self.f1_list = self.loader.load(find("ascii_test_1.txt"))
     self.f1 = self.f1_list[0]
     self.f2_list = self.loader.load(find("ascii_test_2.txt"))
     self.f2 = self.f2_list[0]
     self.f3_list = self.loader.load(find("ascii_test_3.txt"))
     self.f3 = self.f3_list[0]
     self.f4_list = self.loader.load(find("ascii_test_4.abs"))
     self.f4 = self.f4_list[0]
     self.f5_list = self.loader.load(find("ascii_test_5.txt"))
     self.f5 = self.f5_list[0]

 def __init__(self, path, completefn=None,
              updatefn=None,
              yieldtime=0.01,
              worktime=0.01
              ):
     CalcThread.__init__(self, completefn,
              updatefn,
              yieldtime,
              worktime)
     self.path = path
     #Instantiate a loader 
     self.loader = Loader()
     self.starttime = 0

class designtest(unittest.TestCase):
    
    def setUp(self):
        self.loader = Loader()
        
    def test_singleton(self):
        """
            Testing whether Loader is truly a singleton
        """
        # Create a 'new' Loader
        b = Loader()
        self.assertEqual(self.loader._get_registry_creation_time(),
                         b._get_registry_creation_time())

    def setUp(self):
        self.loader = Loader()
        self.writer = NXcanSASWriter()
        self.read_file_1d = "cansas1d.xml"
        self.write_file_1d = "export1d.h5"
        self.read_file_2d = "exp18_14_igor_2dqxqy.dat"
        self.write_file_2d = "export2d.h5"

        self.data_1d = self.loader.load(self.read_file_1d)[0]

        self.data_2d = self.loader.load(self.read_file_2d)[0]
        self.data_2d.detector[0].name = ''
        self.data_2d.source.radiation = 'neutron'

 def OnLoad(self,event):
     path = None
     dlg = wx.FileDialog(None, "Choose a file", os.getcwd(), "", "*", wx.OPEN)
     if dlg.ShowModal() == wx.ID_OK:
         path = dlg.GetPath()
         mypath = os.path.basename(path)
         from sas.sascalc.dataloader.loader import  Loader
        
         #Instantiate a loader 
         L=Loader()
         
         #Receives data
         try:
             output=L.load(path)
         except:
             raise
        
         newplot=Data2D(image=output.data)
         newplot.setValues(output)
         self.plotpanel.add_image(newplot)
        
             
     dlg.Destroy()