schain Commit - r1472:c5c71a942112 · Jicamarca Repository

nuevo

joabAM -

r1472:c5c71a942112

parent child

Context file:

r1472:c5c71a942112

Collapse all files

schainc/_noise.c +48 0

@@ -49,7 +49,55 static PyObject hildebrand_sekhon(PyObject self, PyObject *args) {
49	// return PyLong_FromLong(lnoise);	49	// return PyLong_FromLong(lnoise);
50	return PyFloat_FromDouble(lnoise);	50	return PyFloat_FromDouble(lnoise);
51	}	51	}
		52	/*
		53	static PyObject hildebrand_sekhon2(PyObject self, PyObject *args) {
		54	double navg;
		55	double th;
		56	PyObject data_obj, data_array;
		57
		58	if (!PyArg_ParseTuple(args, "Od", &data_obj, &navg, &th)) {
		59	return NULL;
		60	}
		61
		62	data_array = PyArray_FROM_OTF(data_obj, NPY_FLOAT64, NPY_IN_ARRAY);
		63
		64	if (data_array == NULL) {
		65	Py_XDECREF(data_array);
		66	Py_XDECREF(data_obj);
		67	return NULL;
		68	}
		69	double sortdata = (double)PyArray_DATA(data_array);
		70	int lenOfData = (int)PyArray_SIZE(data_array) ;
		71	double nums_min = lenOfData*th;
		72	if (nums_min <= 5) nums_min = 5;
		73	double sump = 0;
		74	double sumq = 0;
		75	long j = 0;
		76	int cont = 1;
		77	double rtest = 0;
		78	while ((cont == 1) && (j < lenOfData)) {
		79	sump = sump + sortdata[j];
		80	sumq = sumq + pow(sortdata[j], 2);
		81	if (j > nums_min) {
		82	rtest = (double)j/(j-1) + 1/navg;
		83	if ((sumqj) > (rtestpow(sump, 2))) {
		84	j = j - 1;
		85	sump = sump - sortdata[j];
		86	sumq = sumq - pow(sortdata[j],2);
		87	cont = 0;
		88	}
		89	}
		90	j = j + 1;
		91	}
52		92
		93	//double lnoise = sump / j;
		94
		95	Py_DECREF(data_array);
		96
		97	// return PyLong_FromLong(lnoise);
		98	return PyFloat_FromDouble(j,sortID);
		99	}
		100	*/
53		101
54	static PyMethodDef noiseMethods[] = {	102	static PyMethodDef noiseMethods[] = {
55	{ "hildebrand_sekhon", hildebrand_sekhon, METH_VARARGS, "Get noise with hildebrand_sekhon algorithm" },	103	{ "hildebrand_sekhon", hildebrand_sekhon, METH_VARARGS, "Get noise with hildebrand_sekhon algorithm" },

schainpy/model/graphics/jroplot_parameters.py +5 -3

                 def update(self, dataOut):
                     if len(self.channelList) == 0:
                         self.update_list(dataOut)
-                    data = {}
                     meta = {}
-                    data['snr'] = 10*numpy.log10(dataOut.data_snr)
+                    data = {
+                        'snr': 10 * numpy.log10(dataOut.data_snr)
+                    }
+                    #print(data['snr'])
                     return data, meta
             class DopplerPlot(RTIPlot):

schainpy/model/graphics/jroplot_spectra.py +6 -2

                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data[self.CODE]
                     self.z = numpy.array(self.z, dtype=float)
                     self.z = numpy.ma.masked_invalid(self.z)
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
-                    dummy_var = self.axes #Extrañamente esto actualiza el valor axes
+                    #dummy_var = self.axes #Extrañamente esto actualiza el valor axes
                     for n, ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         data = self.data[-1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    )
                             if self.showprofile:
                                 ax.plot_profile = self.pf_axes[n].plot(data[self.CODE][n], self.y)[0]
                                 if "noise" in self.data:
                                     ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(data['noise'][n], len(self.y)), self.y,
                                                                      color="k", linestyle="dashed", lw=1)[0]
                         else:
                             if self.showprofile:
                                 ax.plot_profile.set_data(data[self.CODE][n], self.y)
                                 if "noise" in self.data:
                                     ax.plot_noise.set_data(numpy.repeat(
                                     data['noise'][n], len(self.y)), self.y)

schainpy/model/io/jroIO_param.py +4 -4

                     self.getData()
-            #@MPDecorator
+            @MPDecorator
-            class HDFWrite(Operation):
+            class HDFWriter(Operation):
                 """Operation to write HDF5 files.
                 The HDF5 file contains by default two groups Data and Metadata where
                 def run(self, dataOut,**kwargs):
-                    self.dataOut = dataOut
+                    self.dataOut = dataOut.copy()
                     if not(self.isConfig):
                         self.setup(**kwargs)
                     self.putData()
-                    return self.dataOut
+                    #return self.dataOut
                 def setNextFile(self):

schainpy/model/proc/jroproc_base.py +1 -1

                         elif optype == 'external' and self.dataOut.error:
                             op.queue.put(copy.deepcopy(self.dataOut))
-                    return 'Error' if self.dataOut.error else True#self.dataOut.isReady()
+                    return 'Error' if self.dataOut.error else self.dataOut.isReady()
                 def setup(self):

schainpy/model/proc/jroproc_spectra.py +18 -9

                             self.dataOut.flagNoData = False
                             self.firstdatatime = None
                             self.profIndex = 0
-                        self.dataOut.noise_estimation = None
                     else:
                         raise ValueError("The type of input object '%s' is not valid".format(
                             self.dataIn.type))
                     return self.dataOut
             class getNoise(Operation):
                 def __init__(self):
                     Operation.__init__(self)
-                def run(self, dataOut, minHei=None, maxHei=None, minVel=None, maxVel=None, minFreq= None, maxFreq=None,):
+                def run(self, dataOut, minHei=None, maxHei=None,minVel=None, maxVel=None, minFreq= None, maxFreq=None):
-                    self.dataOut = dataOut.copy()
+                    self.dataOut = dataOut
-                    print("1: ",dataOut.noise_estimation,  dataOut.normFactor)
                     if minHei == None:
                         minHei = self.dataOut.heightList[0]
                         maxIndexFFT = len( self.dataOut.getFreqRange(1))
                     #print(minIndex, maxIndex,minIndexVel, maxIndexVel)
+                    self.dataOut.noise_estimation = None
                     noise = self.dataOut.getNoise(xmin_index=minIndexFFT, xmax_index=maxIndexFFT, ymin_index=minIndex, ymax_index=maxIndex)
-                    self.dataOut.noise_estimation = noise.copy()
+                    self.dataOut.noise_estimation = noise.copy() # dataOut.noise
                     #print("2: ",10*numpy.log10(self.dataOut.noise_estimation/64))
                     return self.dataOut
                     buffer_cspc=None
                     self.__buffer_spc=numpy.array(self.__buffer_spc)
                     self.__buffer_cspc=numpy.array(self.__buffer_cspc)
                     freq_dc = int(self.__buffer_spc.shape[2] / 2)
                     #print("FREQ_DC",freq_dc,self.__buffer_spc.shape,self.nHeights)
                     for k in range(7,self.nHeights):
-                        buffer_cspc=numpy.copy(self.__buffer_cspc[:,:,:,k])
+                        try:
+                            buffer_cspc=numpy.copy(self.__buffer_cspc[:,:,:,k])
+                        except Exception as e:
+                            print(e)
                         outliers_IDs_cspc=[]
                         cspc_outliers_exist=False
                         for i in range(self.nChannels):#dataOut.nChannels):
                     self.__buffer_cspc = []
                     self.__buffer_dc = 0
                     self.__profIndex = 0
+                    #print("pushData Done")
                     return data_spc, data_cspc, data_dc, n
                 def byProfiles(self, *args):
                     if self.__dataReady:
                         if not self.ByLags:
+                            if self.nChannels == 1:
-                            dataOut.data_spc = numpy.squeeze(avgdata_spc)
+                                dataOut.data_spc = avgdata_spc
+                            else:
+                                dataOut.data_spc = numpy.squeeze(avgdata_spc)
                             dataOut.data_cspc = numpy.squeeze(avgdata_cspc)
                             dataOut.data_dc = avgdata_dc
                         else:
                             dataOut.dataLag_spc = avgdata_spc
                             dataOut.dataLag_cspc = avgdata_cspc

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages