schain Commit - r1313:9610dc8c6549 · Jicamarca Repository

1

import numpy,math,random,time

1

import numpy,math,random,time

2

#---------------1 Heredamos JRODatareader

2

#---------------1 Heredamos JRODatareader

3

from schainpy.model.io.jroIO_base import *

3

from schainpy.model.io.jroIO_base import *

4

#---------------2 Heredamos las propiedades de ProcessingUnit

4

#---------------2 Heredamos las propiedades de ProcessingUnit

5

from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator

5

from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator

6

#---------------3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader

6

#---------------3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader

7

from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader

7

from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader

8

#---------------4 Importaremos el objeto Voltge

8

#---------------4 Importaremos el objeto Voltge

9

from schainpy.model.data.jrodata import Voltage

9

from schainpy.model.data.jrodata import Voltage

10

11

class SimulatorReader(JRODataReader, ProcessingUnit):

11

class SimulatorReader(JRODataReader, ProcessingUnit):

12

incIntFactor = 1

12

incIntFactor = 1

13

nFFTPoints = 0

13

nFFTPoints = 0

14

FixPP_IncInt = 1

14

FixPP_IncInt = 1

15

FixRCP_IPP = 1000

15

FixRCP_IPP = 1000

16

FixPP_CohInt = 1

16

FixPP_CohInt = 1

17

Tau_0 = 250

17

Tau_0 = 250

18

AcqH0_0 = 70

18

AcqH0_0 = 70

19

H0 = AcqH0_0

19

H0 = AcqH0_0

20

AcqDH_0 = 1.25

20

AcqDH_0 = 1.25

21

DH0 = AcqDH_0

21

DH0 = AcqDH_0

22

Bauds = 32

22

Bauds = 32

23

BaudWidth = None

23

BaudWidth = None

24

FixRCP_TXA = 40

24

FixRCP_TXA = 40

25

FixRCP_TXB = 70

25

FixRCP_TXB = 70

26

fAngle = 2.0*math.pi*(1/16)

26

fAngle = 2.0*math.pi*(1/16)

27

DC_level = 500

27

DC_level = 500

28

stdev = 8

28

stdev = 8

29

Num_Codes = 2

29

Num_Codes = 2

30

#code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])

30

#code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])

31

#code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])

31

#code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])

32

#Dyn_snCode = numpy.array([Num_Codes,Bauds])

32

#Dyn_snCode = numpy.array([Num_Codes,Bauds])

33

Dyn_snCode = None

33

Dyn_snCode = None

34

Samples = 200

34

Samples = 200

35

channels = 2

35

channels = 2

36

pulses = None

36

pulses = None

37

Reference = None

37

Reference = None

38

pulse_size = None

38

pulse_size = None

39

prof_gen = None

39

prof_gen = None

40

Fdoppler = 100

40

Fdoppler = 100

41

Hdoppler = 36

41

Hdoppler = 36

42

Adoppler = 300

42

Adoppler = 300

43

frequency = 9345

43

frequency = 9345

44

nTotalReadFiles = 1000

44

nTotalReadFiles = 1000

45

46

def __init__(self):

46

def __init__(self):

47

"""

47

"""

48

Inicializador de la clases SimulatorReader para

48

Inicializador de la clases SimulatorReader para

49

generar datos de voltage simulados.

49

generar datos de voltage simulados.

50

Input:

50

Input:

51

dataOut: Objeto de la clase Voltage.

51

dataOut: Objeto de la clase Voltage.

52

Este Objeto sera utilizado apra almacenar

52

Este Objeto sera utilizado apra almacenar

53

un perfil de datos cada vez qe se haga

53

un perfil de datos cada vez qe se haga

54

un requerimiento (getData)

54

un requerimiento (getData)

55

"""

55

"""

56

ProcessingUnit.__init__(self)

56

ProcessingUnit.__init__(self)

57

print(" [ START ] init - Metodo Simulator Reader")

57

print(" [ START ] init - Metodo Simulator Reader")

58

59

self.isConfig = False

59

self.isConfig = False

60

self.basicHeaderObj = BasicHeader(LOCALTIME)

60

self.basicHeaderObj = BasicHeader(LOCALTIME)

61

self.systemHeaderObj = SystemHeader()

61

self.systemHeaderObj = SystemHeader()

62

self.radarControllerHeaderObj = RadarControllerHeader()

62

self.radarControllerHeaderObj = RadarControllerHeader()

63

self.processingHeaderObj = ProcessingHeader()

63

self.processingHeaderObj = ProcessingHeader()

64

self.profileIndex = 2**32-1

64

self.profileIndex = 2**32-1

65

self.dataOut = Voltage()

65

self.dataOut = Voltage()

66

#code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])

66

#code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])

67

code0 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,1,-1,1,-1,-1,-1,1,1,1,-1,1])

67

code0 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,1,-1,1,-1,-1,-1,1,1,1,-1,1])

68

#code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])

68

#code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])

69

code1 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,1,1,-1,-1,-1,1,-1])

69

code1 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,1,1,-1,-1,-1,1,-1])

70

#self.Dyn_snCode = numpy.array([code0,code1])

70

#self.Dyn_snCode = numpy.array([code0,code1])

71

self.Dyn_snCode = None

71

self.Dyn_snCode = None

72

73

def set_kwargs(self, **kwargs):

73

def set_kwargs(self, **kwargs):

74

for key, value in kwargs.items():

74

for key, value in kwargs.items():

75

setattr(self, key, value)

75

setattr(self, key, value)

76

77

def __hasNotDataInBuffer(self):

77

def __hasNotDataInBuffer(self):

78

79

if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs:

79

if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs:

80

if self.nReadBlocks>0:

80

if self.nReadBlocks>0:

81

tmp = self.dataOut.utctime

81

tmp = self.dataOut.utctime

82

tmp_utc = int(self.dataOut.utctime)

82

tmp_utc = int(self.dataOut.utctime)

83

tmp_milisecond = int((tmp-tmp_utc)*1000)

83

tmp_milisecond = int((tmp-tmp_utc)*1000)

84

self.basicHeaderObj.utc = tmp_utc

84

self.basicHeaderObj.utc = tmp_utc

85

self.basicHeaderObj.miliSecond= tmp_milisecond

85

self.basicHeaderObj.miliSecond= tmp_milisecond

86

return 1

86

return 1

87

return 0

87

return 0

88

89

def setNextFile(self):

89

def setNextFile(self):

90

"""Set the next file to be readed open it and parse de file header"""

90

"""Set the next file to be readed open it and parse de file header"""

91

92

if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):

92

if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):

93

self.nReadFiles=self.nReadFiles+1

93

self.nReadFiles=self.nReadFiles+1

94

if self.nReadFiles > self.nTotalReadFiles:

94

if self.nReadFiles > self.nTotalReadFiles:

95

self.flagNoMoreFiles=1

95

self.flagNoMoreFiles=1

96

raise schainpy.admin.SchainWarning('No more files to read')

96

raise schainpy.admin.SchainWarning('No more files to read')

97

98

print('------------------- [Opening file] ------------------------------',self.nReadFiles)

98

print('------------------- [Opening file] ------------------------------',self.nReadFiles)

99

self.nReadBlocks = 0

99

self.nReadBlocks = 0

100

#if self.nReadBlocks==0:

100

#if self.nReadBlocks==0:

101

# self.readFirstHeader()

101

# self.readFirstHeader()

102

103

def __setNewBlock(self):

103

def __setNewBlock(self):

104

self.setNextFile()

104

self.setNextFile()

105

if self.flagIsNewFile:

105

if self.flagIsNewFile:

106

return 1

106

return 1

107

108

def readNextBlock(self):

108

def readNextBlock(self):

109

while True:

109

while True:

110

self.__setNewBlock()

110

self.__setNewBlock()

111

if not(self.readBlock()):

111

if not(self.readBlock()):

112

return 0

112

return 0

113

self.getBasicHeader()

113

self.getBasicHeader()

114

break

114

break

115

if self.verbose:

115

if self.verbose:

116

print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,

116

print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,

117

self.processingHeaderObj.dataBlocksPerFile,

117

self.processingHeaderObj.dataBlocksPerFile,

118

self.dataOut.datatime.ctime()) )

118

self.dataOut.datatime.ctime()) )

119

return 1

119

return 1

120

121

def getFirstHeader(self):

121

def getFirstHeader(self):

122

self.getBasicHeader()

122

self.getBasicHeader()

123

self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()

123

self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()

124

self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()

124

self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()

125

self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()

125

self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()

126

self.dataOut.dtype = self.dtype

126

self.dataOut.dtype = self.dtype

127

128

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

128

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

129

self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight

129

self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight

130

self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))

130

self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))

131

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

131

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

132

# asumo q la data no esta decodificada

132

# asumo q la data no esta decodificada

133

self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode

133

self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode

134

# asumo q la data no esta sin flip

134

# asumo q la data no esta sin flip

135

self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip

135

self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip

136

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

136

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

137

self.dataOut.frequency = self.frequency

137

self.dataOut.frequency = self.frequency

138

139

def getBasicHeader(self):

139

def getBasicHeader(self):

140

self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \

140

self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \

141

1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds

141

1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds

142

143

self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock

143

self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock

144

self.dataOut.timeZone = self.basicHeaderObj.timeZone

144

self.dataOut.timeZone = self.basicHeaderObj.timeZone

145

self.dataOut.dstFlag = self.basicHeaderObj.dstFlag

145

self.dataOut.dstFlag = self.basicHeaderObj.dstFlag

146

self.dataOut.errorCount = self.basicHeaderObj.errorCount

146

self.dataOut.errorCount = self.basicHeaderObj.errorCount

147

self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime

147

self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime

148

self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs

148

self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs

149

150

def readFirstHeader(self):

150

def readFirstHeader(self):

151

152

datatype = int(numpy.log2((self.processingHeaderObj.processFlags &

152

datatype = int(numpy.log2((self.processingHeaderObj.processFlags &

153

PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))

153

PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))

154

if datatype == 0:

154

if datatype == 0:

155

datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])

155

datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])

156

elif datatype == 1:

156

elif datatype == 1:

157

datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])

157

datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])

158

elif datatype == 2:

158

elif datatype == 2:

159

datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])

159

datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])

160

elif datatype == 3:

160

elif datatype == 3:

161

datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])

161

datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])

162

elif datatype == 4:

162

elif datatype == 4:

163

datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])

163

datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])

164

elif datatype == 5:

164

elif datatype == 5:

165

datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])

165

datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])

166

else:

166

else:

167

raise ValueError('Data type was not defined')

167

raise ValueError('Data type was not defined')

168

169

self.dtype = datatype_str

169

self.dtype = datatype_str

170

171

172

def set_RCH(self, expType=2, nTx=1,ipp=None, txA=0, txB=0,

172

def set_RCH(self, expType=2, nTx=1,ipp=None, txA=0, txB=0,

173

nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,

173

nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,

174

numTaus=0, line6Function=0, line5Function=0, fClock=None,

174

numTaus=0, line6Function=0, line5Function=0, fClock=None,

175

prePulseBefore=0, prePulseAfter=0,

175

prePulseBefore=0, prePulseAfter=0,

176

codeType=0, nCode=0, nBaud=0, code=None,

176

codeType=0, nCode=0, nBaud=0, code=None,

177

flip1=0, flip2=0,Taus=0):

177

flip1=0, flip2=0,Taus=0):

178

self.radarControllerHeaderObj.expType = expType

178

self.radarControllerHeaderObj.expType = expType

179

self.radarControllerHeaderObj.nTx = nTx

179

self.radarControllerHeaderObj.nTx = nTx

180

self.radarControllerHeaderObj.ipp = float(ipp)

180

self.radarControllerHeaderObj.ipp = float(ipp)

181

self.radarControllerHeaderObj.txA = float(txA)

181

self.radarControllerHeaderObj.txA = float(txA)

182

self.radarControllerHeaderObj.txB = float(txB)

182

self.radarControllerHeaderObj.txB = float(txB)

183

self.radarControllerHeaderObj.rangeIpp = b'A\n'#ipp

183

self.radarControllerHeaderObj.rangeIpp = b'A\n'#ipp

184

self.radarControllerHeaderObj.rangeTxA = b''

184

self.radarControllerHeaderObj.rangeTxA = b''

185

self.radarControllerHeaderObj.rangeTxB = b''

185

self.radarControllerHeaderObj.rangeTxB = b''

186

187

self.radarControllerHeaderObj.nHeights = int(nHeights)

187

self.radarControllerHeaderObj.nHeights = int(nHeights)

188

self.radarControllerHeaderObj.firstHeight = numpy.array([firstHeight])

188

self.radarControllerHeaderObj.firstHeight = numpy.array([firstHeight])

189

self.radarControllerHeaderObj.deltaHeight = numpy.array([deltaHeight])

189

self.radarControllerHeaderObj.deltaHeight = numpy.array([deltaHeight])

190

self.radarControllerHeaderObj.samplesWin = numpy.array([nHeights])

190

self.radarControllerHeaderObj.samplesWin = numpy.array([nHeights])

191

192

193

self.radarControllerHeaderObj.nWindows = nWindows

193

self.radarControllerHeaderObj.nWindows = nWindows

194

self.radarControllerHeaderObj.numTaus = numTaus

194

self.radarControllerHeaderObj.numTaus = numTaus

195

self.radarControllerHeaderObj.codeType = codeType

195

self.radarControllerHeaderObj.codeType = codeType

196

self.radarControllerHeaderObj.line6Function = line6Function

196

self.radarControllerHeaderObj.line6Function = line6Function

197

self.radarControllerHeaderObj.line5Function = line5Function

197

self.radarControllerHeaderObj.line5Function = line5Function

198

#self.radarControllerHeaderObj.fClock = fClock

198

#self.radarControllerHeaderObj.fClock = fClock

199

self.radarControllerHeaderObj.prePulseBefore= prePulseBefore

199

self.radarControllerHeaderObj.prePulseBefore= prePulseBefore

200

self.radarControllerHeaderObj.prePulseAfter = prePulseAfter

200

self.radarControllerHeaderObj.prePulseAfter = prePulseAfter

201

202

self.radarControllerHeaderObj.flip1 = flip1

202

self.radarControllerHeaderObj.flip1 = flip1

203

self.radarControllerHeaderObj.flip2 = flip2

203

self.radarControllerHeaderObj.flip2 = flip2

204

205

self.radarControllerHeaderObj.code_size = 0

205

self.radarControllerHeaderObj.code_size = 0

206

if self.radarControllerHeaderObj.codeType != 0:

206

if self.radarControllerHeaderObj.codeType != 0:

207

self.radarControllerHeaderObj.nCode = nCode

207

self.radarControllerHeaderObj.nCode = nCode

208

self.radarControllerHeaderObj.nBaud = nBaud

208

self.radarControllerHeaderObj.nBaud = nBaud

209

self.radarControllerHeaderObj.code = code

209

self.radarControllerHeaderObj.code = code

210

self.radarControllerHeaderObj.code_size = int(numpy.ceil(nBaud / 32.)) * nCode * 4

210

self.radarControllerHeaderObj.code_size = int(numpy.ceil(nBaud / 32.)) * nCode * 4

211

212

if fClock is None and deltaHeight is not None:

212

if fClock is None and deltaHeight is not None:

213

self.fClock = 0.15 / (deltaHeight * 1e-6)

213

self.fClock = 0.15 / (deltaHeight * 1e-6)

214

self.radarControllerHeaderObj.fClock = self.fClock

214

self.radarControllerHeaderObj.fClock = self.fClock

215

if numTaus==0:

215

if numTaus==0:

216

self.radarControllerHeaderObj.Taus = numpy.array(0,'<f4')

216

self.radarControllerHeaderObj.Taus = numpy.array(0,'<f4')

217

else:

217

else:

218

self.radarControllerHeaderObj.Taus = numpy.array(Taus,'<f4')

218

self.radarControllerHeaderObj.Taus = numpy.array(Taus,'<f4')

219

220

def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0,

220

def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0,

221

dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,

221

dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,

222

nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0,

222

nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0,

223

deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0,

223

deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0,

224

code=0, nBaud=None, shif_fft=False, flag_dc=False,

224

code=0, nBaud=None, shif_fft=False, flag_dc=False,

225

flag_cspc=False, flag_decode=False, flag_deflip=False):

225

flag_cspc=False, flag_decode=False, flag_deflip=False):

226

227

self.processingHeaderObj.dtype = dtype

227

self.processingHeaderObj.dtype = dtype

228

self.processingHeaderObj.profilesPerBlock = profilesPerBlock

228

self.processingHeaderObj.profilesPerBlock = profilesPerBlock

229

self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile

229

self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile

230

self.processingHeaderObj.nWindows = nWindows

230

self.processingHeaderObj.nWindows = nWindows

231

self.processingHeaderObj.processFlags = processFlags

231

self.processingHeaderObj.processFlags = processFlags

232

self.processingHeaderObj.nCohInt = nCohInt

232

self.processingHeaderObj.nCohInt = nCohInt

233

self.processingHeaderObj.nIncohInt = nIncohInt

233

self.processingHeaderObj.nIncohInt = nIncohInt

234

self.processingHeaderObj.totalSpectra = totalSpectra

234

self.processingHeaderObj.totalSpectra = totalSpectra

235

236

self.processingHeaderObj.nHeights = int(nHeights)

236

self.processingHeaderObj.nHeights = int(nHeights)

237

self.processingHeaderObj.firstHeight = firstHeight#numpy.array([firstHeight])#firstHeight

237

self.processingHeaderObj.firstHeight = firstHeight#numpy.array([firstHeight])#firstHeight

238

self.processingHeaderObj.deltaHeight = deltaHeight#numpy.array([deltaHeight])#deltaHeight

238

self.processingHeaderObj.deltaHeight = deltaHeight#numpy.array([deltaHeight])#deltaHeight

239

self.processingHeaderObj.samplesWin = nHeights#numpy.array([nHeights])#nHeights

239

self.processingHeaderObj.samplesWin = nHeights#numpy.array([nHeights])#nHeights

240

241

def set_BH(self, utc = 0, miliSecond = 0, timeZone = 0):

241

def set_BH(self, utc = 0, miliSecond = 0, timeZone = 0):

242

self.basicHeaderObj.utc = utc

242

self.basicHeaderObj.utc = utc

243

self.basicHeaderObj.miliSecond = miliSecond

243

self.basicHeaderObj.miliSecond = miliSecond

244

self.basicHeaderObj.timeZone = timeZone

244

self.basicHeaderObj.timeZone = timeZone

245

246

def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=32):

246

def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=32):

247

#self.systemHeaderObj.size = size

247

#self.systemHeaderObj.size = size

248

self.systemHeaderObj.nSamples = nSamples

248

self.systemHeaderObj.nSamples = nSamples

249

self.systemHeaderObj.nProfiles = nProfiles

249

self.systemHeaderObj.nProfiles = nProfiles

250

self.systemHeaderObj.nChannels = nChannels

250

self.systemHeaderObj.nChannels = nChannels

251

self.systemHeaderObj.adcResolution = adcResolution

251

self.systemHeaderObj.adcResolution = adcResolution

252

self.systemHeaderObj.pciDioBusWidth = pciDioBusWidth

252

self.systemHeaderObj.pciDioBusWidth = pciDioBusWidth

253

254

def init_acquisition(self):

254

def init_acquisition(self):

255

256

if self.nFFTPoints != 0:

256

if self.nFFTPoints != 0:

257

self.incIntFactor = m_nProfilesperBlock/self.nFFTPoints

257

self.incIntFactor = m_nProfilesperBlock/self.nFFTPoints

258

if (self.FixPP_IncInt > self.incIntFactor):

258

if (self.FixPP_IncInt > self.incIntFactor):

259

self.incIntFactor = self.FixPP_IncInt/ self.incIntFactor

259

self.incIntFactor = self.FixPP_IncInt/ self.incIntFactor

260

elif(self.FixPP_IncInt< self.incIntFactor):

260

elif(self.FixPP_IncInt< self.incIntFactor):

261

print("False alert...")

261

print("False alert...")

262

263

ProfilesperBlock = self.processingHeaderObj.profilesPerBlock

263

ProfilesperBlock = self.processingHeaderObj.profilesPerBlock

264

265

self.timeperblock =int(((self.FixRCP_IPP

265

self.timeperblock =int(((self.FixRCP_IPP

266

*ProfilesperBlock

266

*ProfilesperBlock

267

*self.FixPP_CohInt

267

*self.FixPP_CohInt

268

*self.incIntFactor)

268

*self.incIntFactor)

269

/150.0)

269

/150.0)

270

*0.9

270

*0.9

271

+0.5)

271

+0.5)

272

# para cada canal

272

# para cada canal

273

self.profiles = ProfilesperBlock*self.FixPP_CohInt

273

self.profiles = ProfilesperBlock*self.FixPP_CohInt

274

self.profiles = ProfilesperBlock

274

self.profiles = ProfilesperBlock

275

self.Reference = int((self.Tau_0-self.AcqH0_0)/(self.AcqDH_0)+0.5)

275

self.Reference = int((self.Tau_0-self.AcqH0_0)/(self.AcqDH_0)+0.5)

276

self.BaudWidth = int((self.FixRCP_TXA/self.AcqDH_0)/self.Bauds + 0.5 )

276

self.BaudWidth = int((self.FixRCP_TXA/self.AcqDH_0)/self.Bauds + 0.5 )

277

278

if (self.BaudWidth==0):

278

if (self.BaudWidth==0):

279

self.BaudWidth=1

279

self.BaudWidth=1

280

281

def init_pulse(self,Num_Codes=Num_Codes,Bauds=Bauds,BaudWidth=BaudWidth,Dyn_snCode=Dyn_snCode):

281

def init_pulse(self,Num_Codes=Num_Codes,Bauds=Bauds,BaudWidth=BaudWidth,Dyn_snCode=Dyn_snCode):

282

283

Num_Codes = Num_Codes

283

Num_Codes = Num_Codes

284

Bauds = Bauds

284

Bauds = Bauds

285

BaudWidth = BaudWidth

285

BaudWidth = BaudWidth

286

Dyn_snCode = Dyn_snCode

286

Dyn_snCode = Dyn_snCode

287

288

if Dyn_snCode:

288

if Dyn_snCode:

289

print("EXISTE")

289

print("EXISTE")

290

else:

290

else:

291

print("No existe")

291

print("No existe")

292

293

if Dyn_snCode: # if Bauds:

293

if Dyn_snCode: # if Bauds:

294

pulses = list(range(0,Num_Codes))

294

pulses = list(range(0,Num_Codes))

295

num_codes = Num_Codes

295

num_codes = Num_Codes

296

for i in range(num_codes):

296

for i in range(num_codes):

297

pulse_size = Bauds*BaudWidth

297

pulse_size = Bauds*BaudWidth

298

pulses[i] = numpy.zeros(pulse_size)

298

pulses[i] = numpy.zeros(pulse_size)

299

for j in range(Bauds):

299

for j in range(Bauds):

300

for k in range(BaudWidth):

300

for k in range(BaudWidth):

301

pulses[i][j*BaudWidth+k] = int(Dyn_snCode[i][j]*600)

301

pulses[i][j*BaudWidth+k] = int(Dyn_snCode[i][j]*600)

302

else:

302

else:

303

print("sin code")

303

print("sin code")

304

pulses = list(range(1))

304

pulses = list(range(1))

305

if self.AcqDH_0>0.149:

305

if self.AcqDH_0>0.149:

306

pulse_size = int(self.FixRCP_TXB/0.15+0.5)

306

pulse_size = int(self.FixRCP_TXB/0.15+0.5)

307

else:

307

else:

308

pulse_size = int((self.FixRCP_TXB/self.AcqDH_0)+0.5) #0.0375

308

pulse_size = int((self.FixRCP_TXB/self.AcqDH_0)+0.5) #0.0375

309

pulses[0] = numpy.ones(pulse_size)

309

pulses[0] = numpy.ones(pulse_size)

310

pulses = 600*pulses[0]

310

pulses = 600*pulses[0]

311

312

return pulses,pulse_size

312

return pulses,pulse_size

313

314

def jro_GenerateBlockOfData(self,Samples=Samples,DC_level= DC_level,stdev=stdev,

314

def jro_GenerateBlockOfData(self,Samples=Samples,DC_level= DC_level,stdev=stdev,

315

Reference= Reference,pulses= pulses,

315

Reference= Reference,pulses= pulses,

316

Num_Codes= Num_Codes,pulse_size=pulse_size,

316

Num_Codes= Num_Codes,pulse_size=pulse_size,

317

prof_gen= prof_gen,H0 = H0,DH0=DH0,

317

prof_gen= prof_gen,H0 = H0,DH0=DH0,

318

Adoppler=Adoppler,Fdoppler= Fdoppler,Hdoppler=Hdoppler):

318

Adoppler=Adoppler,Fdoppler= Fdoppler,Hdoppler=Hdoppler):

319

Samples = Samples

319

Samples = Samples

320

DC_level = DC_level

320

DC_level = DC_level

321

stdev = stdev

321

stdev = stdev

322

m_nR = Reference

322

m_nR = Reference

323

pulses = pulses

323

pulses = pulses

324

num_codes = Num_Codes

324

num_codes = Num_Codes

325

ps = pulse_size

325

ps = pulse_size

326

prof_gen = prof_gen

326

prof_gen = prof_gen

327

channels = self.channels

327

channels = self.channels

328

H0 = H0

328

H0 = H0

329

DH0 = DH0

329

DH0 = DH0

330

ippSec = self.radarControllerHeaderObj.ippSeconds

330

ippSec = self.radarControllerHeaderObj.ippSeconds

331

Fdoppler = self.Fdoppler

331

Fdoppler = self.Fdoppler

332

Hdoppler = self.Hdoppler

332

Hdoppler = self.Hdoppler

333

Adoppler = self.Adoppler

333

Adoppler = self.Adoppler

334

335

self.datablock = numpy.zeros([channels,prof_gen,Samples],dtype= numpy.complex64)

335

self.datablock = numpy.zeros([channels,prof_gen,Samples],dtype= numpy.complex64)

336

for i in range(channels):

336

for i in range(channels):

337

for k in range(prof_gen):

337

for k in range(prof_gen):

338

#·······················NOISE···············

338

#·······················NOISE···············

339

Noise_r = numpy.random.normal(DC_level,stdev,Samples)

339

Noise_r = numpy.random.normal(DC_level,stdev,Samples)

340

Noise_i = numpy.random.normal(DC_level,stdev,Samples)

340

Noise_i = numpy.random.normal(DC_level,stdev,Samples)

341

Noise = numpy.zeros(Samples,dtype=complex)

341

Noise = numpy.zeros(Samples,dtype=complex)

342

Noise.real = Noise_r

342

Noise.real = Noise_r

343

Noise.imag = Noise_i

343

Noise.imag = Noise_i

344

#·······················PULSOS··············

344

#·······················PULSOS··············

345

Pulso = numpy.zeros(pulse_size,dtype=complex)

345

Pulso = numpy.zeros(pulse_size,dtype=complex)

346

Pulso.real = pulses[k%num_codes]

346

Pulso.real = pulses[k%num_codes]

347

Pulso.imag = pulses[k%num_codes]

347

Pulso.imag = pulses[k%num_codes]

348

#····················· PULSES+NOISE··········

348

#····················· PULSES+NOISE··········

349

InBuffer = numpy.zeros(Samples,dtype=complex)

349

InBuffer = numpy.zeros(Samples,dtype=complex)

350

InBuffer[m_nR:m_nR+ps] = Pulso

350

InBuffer[m_nR:m_nR+ps] = Pulso

351

InBuffer = InBuffer+Noise

351

InBuffer = InBuffer+Noise

352

#····················· ANGLE ·······························

352

#····················· ANGLE ·······························

353

InBuffer.real[m_nR:m_nR+ps] = InBuffer.real[m_nR:m_nR+ps]*(math.cos( self.fAngle)*5)

353

InBuffer.real[m_nR:m_nR+ps] = InBuffer.real[m_nR:m_nR+ps]*(math.cos( self.fAngle)*5)

354

InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps]*(math.sin( self.fAngle)*5)

354

InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps]*(math.sin( self.fAngle)*5)

355

InBuffer=InBuffer

355

InBuffer=InBuffer

356

self.datablock[i][k]= InBuffer

356

self.datablock[i][k]= InBuffer

357

358

#················DOPPLER SIGNAL...............................................

358

#················DOPPLER SIGNAL...............................................

359

time_vec = numpy.linspace(0,(prof_gen-1)*ippSec,int(prof_gen))+self.nReadBlocks*ippSec*prof_gen+(self.nReadFiles-1)*ippSec*prof_gen

359

time_vec = numpy.linspace(0,(prof_gen-1)*ippSec,int(prof_gen))+self.nReadBlocks*ippSec*prof_gen+(self.nReadFiles-1)*ippSec*prof_gen

360

fd = Fdoppler #+(600.0/120)*self.nReadBlocks

360

fd = Fdoppler #+(600.0/120)*self.nReadBlocks

361

d_signal = Adoppler*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)

361

d_signal = Adoppler*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)

362

#·············Señal con ancho espectral····················

362

#·············Señal con ancho espectral····················

363

#specw_sig = numpy.linspace(-149,150,300)

363

if prof_gen%2==0:

364

#w = 8

364

min = int(prof_gen/2.0-1.0)

365

#A = 20

365

max = int(prof_gen/2.0)

366

#specw_sig = specw_sig/w

366

else:

367

#specw_sig = numpy.sinc(specw_sig)

367

min = int(prof_gen/2.0)

368

#specw_sig = A*numpy.array(specw_sig,dtype=numpy.complex64)

368

max = int(prof_gen/2.0)

369

specw_sig = numpy.linspace(-min,max,prof_gen)

370

w = 4

371

A = 20

372

specw_sig = specw_sig/w

373

specw_sig = numpy.sinc(specw_sig)

374

specw_sig = A*numpy.array(specw_sig,dtype=numpy.complex64)

369

#·················· DATABLOCK + DOPPLER····················

375

#·················· DATABLOCK + DOPPLER····················

370

HD=int(Hdoppler/self.AcqDH_0)

376

HD=int(Hdoppler/self.AcqDH_0)

371

for i in range(12):

377

for i in range(12):

372

self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ d_signal# RESULT

378

self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ d_signal# RESULT

373

#·················· DATABLOCK + DOPPLER*Sinc(x)····················

379

#·················· DATABLOCK + DOPPLER*Sinc(x)····················

374

#HD=int(Hdoppler/self.AcqDH_0)

380

HD=int(Hdoppler/self.AcqDH_0)

375

#HD=int(HD/2)

381

HD=int(HD/2)

376

#for i in range(12):

382

for i in range(12):

377

# self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ specw_sig*d_signal# RESULT

383

self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ specw_sig*d_signal# RESULT

378

384

379

def readBlock(self):

385

def readBlock(self):

380

386

381

self.jro_GenerateBlockOfData(Samples= self.samples,DC_level=self.DC_level,

387

self.jro_GenerateBlockOfData(Samples= self.samples,DC_level=self.DC_level,

382

stdev=self.stdev,Reference= self.Reference,

388

stdev=self.stdev,Reference= self.Reference,

383

pulses = self.pulses,Num_Codes=self.Num_Codes,

389

pulses = self.pulses,Num_Codes=self.Num_Codes,

384

pulse_size=self.pulse_size,prof_gen=self.profiles,

390

pulse_size=self.pulse_size,prof_gen=self.profiles,

385

H0=self.H0,DH0=self.DH0)

391

H0=self.H0,DH0=self.DH0)

386

392

387

self.profileIndex = 0

393

self.profileIndex = 0

388

self.flagIsNewFile = 0

394

self.flagIsNewFile = 0

389

self.flagIsNewBlock = 1

395

self.flagIsNewBlock = 1

390

self.nTotalBlocks += 1

396

self.nTotalBlocks += 1

391

self.nReadBlocks += 1

397

self.nReadBlocks += 1

392

398

393

return 1

399

return 1

394

400

395

401

396

def getData(self):

402

def getData(self):

397

if self.flagNoMoreFiles:

403

if self.flagNoMoreFiles:

398

self.dataOut.flagNodata = True

404

self.dataOut.flagNodata = True

399

return 0

405

return 0

400

self.flagDiscontinuousBlock = 0

406

self.flagDiscontinuousBlock = 0

401

self.flagIsNewBlock = 0

407

self.flagIsNewBlock = 0

402

if self.__hasNotDataInBuffer(): # aqui es verdad

408

if self.__hasNotDataInBuffer(): # aqui es verdad

403

if not(self.readNextBlock()): # return 1 y por eso el if not salta a getBasic Header

409

if not(self.readNextBlock()): # return 1 y por eso el if not salta a getBasic Header

404

return 0

410

return 0

405

self.getFirstHeader() # atributo

411

self.getFirstHeader() # atributo

406

412

407

if not self.getByBlock:

413

if not self.getByBlock:

408

self.dataOut.flagDataAsBlock = False

414

self.dataOut.flagDataAsBlock = False

409

self.dataOut.data = self.datablock[:, self.profileIndex, :]

415

self.dataOut.data = self.datablock[:, self.profileIndex, :]

410

self.dataOut.profileIndex = self.profileIndex

416

self.dataOut.profileIndex = self.profileIndex

411

self.profileIndex += 1

417

self.profileIndex += 1

412

else:

418

else:

413

pass

419

pass

414

self.dataOut.flagNoData = False

420

self.dataOut.flagNoData = False

415

self.getBasicHeader()

421

self.getBasicHeader()

416

self.dataOut.realtime = self.online

422

self.dataOut.realtime = self.online

417

return self.dataOut.data

423

return self.dataOut.data

418

424

419

425

420

def setup(self,frequency=49.92e6,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=1000,

426

def setup(self,frequency=49.92e6,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=1000,

421

FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32,

427

FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32,

422

FixRCP_TXA = 40, FixRCP_TXB = 50, fAngle = 2.0*math.pi*(1/16),DC_level= 50,

428

FixRCP_TXA = 40, FixRCP_TXB = 50, fAngle = 2.0*math.pi*(1/16),DC_level= 50,

423

stdev= 8,Num_Codes = 1 , Dyn_snCode = None, samples=200,

429

stdev= 8,Num_Codes = 1 , Dyn_snCode = None, samples=200,

424

channels=2,Fdoppler=20,Hdoppler=36,Adoppler=500,~~nTotalReadFiles~~=~~10000~~,

430

channels=2,Fdoppler=20,Hdoppler=36,Adoppler=500,

431

profilesPerBlock=300,dataBlocksPerFile=120,nTotalReadFiles=10000,

425

**kwargs):

432

**kwargs):

426

433

427

self.set_kwargs(**kwargs)

434

self.set_kwargs(**kwargs)

428

self.nReadBlocks = 0

435

self.nReadBlocks = 0

429

self.nReadFiles = 1

436

self.nReadFiles = 1

430

print('------------------- [Opening file: ] ------------------------------',self.nReadFiles)

437

print('------------------- [Opening file: ] ------------------------------',self.nReadFiles)

431

438

432

tmp = time.time()

439

tmp = time.time()

433

tmp_utc = int(tmp)

440

tmp_utc = int(tmp)

434

tmp_milisecond = int((tmp-tmp_utc)*1000)

441

tmp_milisecond = int((tmp-tmp_utc)*1000)

435

print(" SETUP -basicHeaderObj.utc",datetime.datetime.utcfromtimestamp(tmp))

442

print(" SETUP -basicHeaderObj.utc",datetime.datetime.utcfromtimestamp(tmp))

436

if Dyn_snCode is None:

443

if Dyn_snCode is None:

437

Num_Codes=1

444

Num_Codes=1

438

Bauds =1

445

Bauds =1

439

446

440

447

441

448

442

self.set_BH(utc= tmp_utc,miliSecond= tmp_milisecond,timeZone=300 )

449

self.set_BH(utc= tmp_utc,miliSecond= tmp_milisecond,timeZone=300 )

443

self.set_RCH( expType=0, nTx=150,ipp=FixRCP_IPP, txA=FixRCP_TXA, txB= FixRCP_TXB,

450

self.set_RCH( expType=0, nTx=150,ipp=FixRCP_IPP, txA=FixRCP_TXA, txB= FixRCP_TXB,

444

nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0,

451

nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0,

445

numTaus=1, line6Function=0, line5Function=0, fClock=None,

452

numTaus=1, line6Function=0, line5Function=0, fClock=None,

446

prePulseBefore=0, prePulseAfter=0,

453

prePulseBefore=0, prePulseAfter=0,

447

codeType=0, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,

454

codeType=0, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,

448

flip1=0, flip2=0,Taus=Tau_0)

455

flip1=0, flip2=0,Taus=Tau_0)

449

456

450

self.set_PH(dtype=0, blockSize=0, profilesPerBlock=~~300~~,

457

self.set_PH(dtype=0, blockSize=0, profilesPerBlock=profilesPerBlock,

451

dataBlocksPerFile=~~120~~, nWindows=1, processFlags=numpy.array([1024]), nCohInt=1,

458

dataBlocksPerFile=dataBlocksPerFile, nWindows=1, processFlags=numpy.array([1024]), nCohInt=1,

452

nIncohInt=1, totalSpectra=0, nHeights=samples, firstHeight=AcqH0_0,

459

nIncohInt=1, totalSpectra=0, nHeights=samples, firstHeight=AcqH0_0,

453

deltaHeight=AcqDH_0, samplesWin=samples, spectraComb=0, nCode=0,

460

deltaHeight=AcqDH_0, samplesWin=samples, spectraComb=0, nCode=0,

454

code=0, nBaud=None, shif_fft=False, flag_dc=False,

461

code=0, nBaud=None, shif_fft=False, flag_dc=False,

455

flag_cspc=False, flag_decode=False, flag_deflip=False)

462

flag_cspc=False, flag_decode=False, flag_deflip=False)

456

463

457

self.set_SH(nSamples=samples, nProfiles=~~300~~, nChannels=channels)

464

self.set_SH(nSamples=samples, nProfiles=profilesPerBlock, nChannels=channels)

458

465

459

self.readFirstHeader()

466

self.readFirstHeader()

460

467

461

self.frequency = frequency

468

self.frequency = frequency

462

self.incIntFactor = incIntFactor

469

self.incIntFactor = incIntFactor

463

self.nFFTPoints = nFFTPoints

470

self.nFFTPoints = nFFTPoints

464

self.FixPP_IncInt = FixPP_IncInt

471

self.FixPP_IncInt = FixPP_IncInt

465

self.FixRCP_IPP = FixRCP_IPP

472

self.FixRCP_IPP = FixRCP_IPP

466

self.FixPP_CohInt = FixPP_CohInt

473

self.FixPP_CohInt = FixPP_CohInt

467

self.Tau_0 = Tau_0

474

self.Tau_0 = Tau_0

468

self.AcqH0_0 = AcqH0_0

475

self.AcqH0_0 = AcqH0_0

469

self.H0 = AcqH0_0

476

self.H0 = AcqH0_0

470

self.AcqDH_0 = AcqDH_0

477

self.AcqDH_0 = AcqDH_0

471

self.DH0 = AcqDH_0

478

self.DH0 = AcqDH_0

472

self.Bauds = Bauds

479

self.Bauds = Bauds

473

self.FixRCP_TXA = FixRCP_TXA

480

self.FixRCP_TXA = FixRCP_TXA

474

self.FixRCP_TXB = FixRCP_TXB

481

self.FixRCP_TXB = FixRCP_TXB

475

self.fAngle = fAngle

482

self.fAngle = fAngle

476

self.DC_level = DC_level

483

self.DC_level = DC_level

477

self.stdev = stdev

484

self.stdev = stdev

478

self.Num_Codes = Num_Codes

485

self.Num_Codes = Num_Codes

479

self.Dyn_snCode = Dyn_snCode

486

self.Dyn_snCode = Dyn_snCode

480

self.samples = samples

487

self.samples = samples

481

self.channels = channels

488

self.channels = channels

482

self.profiles = None

489

self.profiles = None

483

self.m_nReference = None

490

self.m_nReference = None

484

self.Baudwidth = None

491

self.Baudwidth = None

485

self.Fdoppler = Fdoppler

492

self.Fdoppler = Fdoppler

486

self.Hdoppler = Hdoppler

493

self.Hdoppler = Hdoppler

487

self.Adoppler = Adoppler

494

self.Adoppler = Adoppler

488

self.nTotalReadFiles = int(nTotalReadFiles)

495

self.nTotalReadFiles = int(nTotalReadFiles)

489

496

490

print("IPP ", self.FixRCP_IPP)

497

print("IPP ", self.FixRCP_IPP)

491

print("Tau_0 ",self.Tau_0)

498

print("Tau_0 ",self.Tau_0)

492

print("AcqH0_0",self.AcqH0_0)

499

print("AcqH0_0",self.AcqH0_0)

493

print("samples,window ",self.samples)

500

print("samples,window ",self.samples)

494

print("AcqDH_0",AcqDH_0)

501

print("AcqDH_0",AcqDH_0)

495

print("FixRCP_TXA",self.FixRCP_TXA)

502

print("FixRCP_TXA",self.FixRCP_TXA)

496

print("FixRCP_TXB",self.FixRCP_TXB)

503

print("FixRCP_TXB",self.FixRCP_TXB)

497

print("Dyn_snCode",Dyn_snCode)

504

print("Dyn_snCode",Dyn_snCode)

498

print("Fdoppler", Fdoppler)

505

print("Fdoppler", Fdoppler)

499

print("Hdoppler",Hdoppler)

506

print("Hdoppler",Hdoppler)

500

print("Vdopplermax",Fdoppler*(3.0e8/self.frequency)/2.0)

507

print("Vdopplermax",Fdoppler*(3.0e8/self.frequency)/2.0)

501

print("nTotalReadFiles", nTotalReadFiles)

508

print("nTotalReadFiles", nTotalReadFiles)

502

509

503

self.init_acquisition()

510

self.init_acquisition()

504

self.pulses,self.pulse_size=self.init_pulse(Num_Codes=self.Num_Codes,Bauds=self.Bauds,BaudWidth=self.BaudWidth,Dyn_snCode=Dyn_snCode)

511

self.pulses,self.pulse_size=self.init_pulse(Num_Codes=self.Num_Codes,Bauds=self.Bauds,BaudWidth=self.BaudWidth,Dyn_snCode=Dyn_snCode)

505

print(" [ END ] - SETUP metodo")

512

print(" [ END ] - SETUP metodo")

506

return

513

return

507

514

508

def run(self,**kwargs): # metodo propio

515

def run(self,**kwargs): # metodo propio

509

if not(self.isConfig):

516

if not(self.isConfig):

510

self.setup(**kwargs)

517

self.setup(**kwargs)

511

self.isConfig = True

518

self.isConfig = True

512

self.getData()

519

self.getData()

	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

             import numpy,math,random,time
             #---------------1  Heredamos JRODatareader
             from schainpy.model.io.jroIO_base import *
             #---------------2 Heredamos las propiedades de ProcessingUnit
             from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator
             #---------------3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader
             #---------------4 Importaremos el objeto Voltge
             from schainpy.model.data.jrodata import Voltage
             class SimulatorReader(JRODataReader, ProcessingUnit):
                 incIntFactor                   = 1
                 nFFTPoints                     = 0
                 FixPP_IncInt                   = 1
                 FixRCP_IPP                     = 1000
                 FixPP_CohInt                   = 1
                 Tau_0                          = 250
                 AcqH0_0                        = 70
                 H0                             = AcqH0_0
                 AcqDH_0                        = 1.25
                 DH0                            = AcqDH_0
                 Bauds                          = 32
                 BaudWidth                      = None
                 FixRCP_TXA                     = 40
                 FixRCP_TXB                     = 70
                 fAngle                         = 2.0*math.pi*(1/16)
                 DC_level                       = 500
                 stdev                          = 8
                 Num_Codes                      = 2
                 #code0                          = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])
                 #code1                          = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])
                 #Dyn_snCode                     = numpy.array([Num_Codes,Bauds])
                 Dyn_snCode                     = None
                 Samples                        = 200
                 channels                       = 2
                 pulses                         = None
                 Reference                      = None
                 pulse_size                     = None
                 prof_gen                       = None
                 Fdoppler                       = 100
                 Hdoppler                       = 36
                 Adoppler                       = 300
                 frequency                      = 9345
                 nTotalReadFiles                = 1000
                 def __init__(self):
                     """
                     Inicializador de la clases SimulatorReader para
                     generar datos de voltage simulados.
                     Input:
                         dataOut: Objeto de la clase Voltage.
                         Este Objeto sera utilizado apra almacenar
                         un perfil de datos  cada vez qe se haga
                         un requerimiento (getData)
                     """
                     ProcessingUnit.__init__(self)
                     print(" [ START ] init - Metodo Simulator Reader")
                     self.isConfig                  = False
                     self.basicHeaderObj            = BasicHeader(LOCALTIME)
                     self.systemHeaderObj           = SystemHeader()
                     self.radarControllerHeaderObj  = RadarControllerHeader()
                     self.processingHeaderObj       = ProcessingHeader()
                     self.profileIndex              = 2**32-1
                     self.dataOut                   = Voltage()
                     #code0                          = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])
                     code0                          = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,1,-1,1,-1,-1,-1,1,1,1,-1,1])
                     #code1                          = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])
                     code1                          = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,1,1,-1,-1,-1,1,-1])
                     #self.Dyn_snCode                = numpy.array([code0,code1])
                     self.Dyn_snCode                = None
                 def set_kwargs(self, **kwargs):
                     for key, value in kwargs.items():
                         setattr(self, key, value)
                 def __hasNotDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs:
                         if self.nReadBlocks>0:
                             tmp                           = self.dataOut.utctime
                             tmp_utc                       = int(self.dataOut.utctime)
                             tmp_milisecond                = int((tmp-tmp_utc)*1000)
                             self.basicHeaderObj.utc       = tmp_utc
                             self.basicHeaderObj.miliSecond= tmp_milisecond
                         return 1
                     return 0
                 def setNextFile(self):
                     """Set the next file to be readed open it and parse de file header"""
                     if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
                         self.nReadFiles=self.nReadFiles+1
                         if self.nReadFiles > self.nTotalReadFiles:
                             self.flagNoMoreFiles=1
                             raise schainpy.admin.SchainWarning('No more files to read')
                         print('------------------- [Opening file] ------------------------------',self.nReadFiles)
                         self.nReadBlocks  = 0
                     #if self.nReadBlocks==0:
                     #    self.readFirstHeader()
                 def __setNewBlock(self):
                     self.setNextFile()
                     if self.flagIsNewFile:
                         return 1
                 def readNextBlock(self):
                     while True:
                         self.__setNewBlock()
                         if not(self.readBlock()):
                             return 0
                         self.getBasicHeader()
                         break
                     if self.verbose:
                         print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
                                                                   self.processingHeaderObj.dataBlocksPerFile,
                                                                   self.dataOut.datatime.ctime()) )
                     return 1
                 def getFirstHeader(self):
                     self.getBasicHeader()
                     self.dataOut.processingHeaderObj      = self.processingHeaderObj.copy()
                     self.dataOut.systemHeaderObj          = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     self.dataOut.dtype       = self.dtype
                     self.dataOut.nProfiles   = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.heightList  = numpy.arange(self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
                     self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
                     self.dataOut.nCohInt     = self.processingHeaderObj.nCohInt
                     # asumo q la data no esta decodificada
                     self.dataOut.flagDecodeData  = self.processingHeaderObj.flag_decode
                     # asumo q la data no esta sin flip
                     self.dataOut.flagDeflipData  = self.processingHeaderObj.flag_deflip
                     self.dataOut.flagShiftFFT    = self.processingHeaderObj.shif_fft
                     self.dataOut.frequency       = self.frequency
                 def getBasicHeader(self):
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
 . + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
                     self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
                     self.dataOut.timeZone               = self.basicHeaderObj.timeZone
                     self.dataOut.dstFlag                = self.basicHeaderObj.dstFlag
                     self.dataOut.errorCount             = self.basicHeaderObj.errorCount
                     self.dataOut.useLocalTime           = self.basicHeaderObj.useLocalTime
                     self.dataOut.ippSeconds             = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                 def readFirstHeader(self):
                     datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
                                                PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                     else:
                         raise ValueError('Data type was not defined')
                     self.dtype = datatype_str
                 def set_RCH(self, expType=2, nTx=1,ipp=None, txA=0, txB=0,
                              nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
                              numTaus=0, line6Function=0, line5Function=0, fClock=None,
                              prePulseBefore=0, prePulseAfter=0,
                              codeType=0, nCode=0, nBaud=0, code=None,
                              flip1=0, flip2=0,Taus=0):
                     self.radarControllerHeaderObj.expType       = expType
                     self.radarControllerHeaderObj.nTx           = nTx
                     self.radarControllerHeaderObj.ipp           = float(ipp)
                     self.radarControllerHeaderObj.txA           = float(txA)
                     self.radarControllerHeaderObj.txB           = float(txB)
                     self.radarControllerHeaderObj.rangeIpp      = b'A\n'#ipp
                     self.radarControllerHeaderObj.rangeTxA      = b''
                     self.radarControllerHeaderObj.rangeTxB      = b''
                     self.radarControllerHeaderObj.nHeights      = int(nHeights)
                     self.radarControllerHeaderObj.firstHeight   = numpy.array([firstHeight])
                     self.radarControllerHeaderObj.deltaHeight   = numpy.array([deltaHeight])
                     self.radarControllerHeaderObj.samplesWin    = numpy.array([nHeights])
                     self.radarControllerHeaderObj.nWindows      = nWindows
                     self.radarControllerHeaderObj.numTaus       = numTaus
                     self.radarControllerHeaderObj.codeType      = codeType
                     self.radarControllerHeaderObj.line6Function = line6Function
                     self.radarControllerHeaderObj.line5Function = line5Function
                     #self.radarControllerHeaderObj.fClock        = fClock
                     self.radarControllerHeaderObj.prePulseBefore= prePulseBefore
                     self.radarControllerHeaderObj.prePulseAfter = prePulseAfter
                     self.radarControllerHeaderObj.flip1         = flip1
                     self.radarControllerHeaderObj.flip2         = flip2
                     self.radarControllerHeaderObj.code_size     = 0
                     if self.radarControllerHeaderObj.codeType  != 0:
                         self.radarControllerHeaderObj.nCode         = nCode
                         self.radarControllerHeaderObj.nBaud         = nBaud
                         self.radarControllerHeaderObj.code          = code
                         self.radarControllerHeaderObj.code_size     = int(numpy.ceil(nBaud / 32.)) * nCode * 4
                     if fClock is None and deltaHeight is not None:
                         self.fClock = 0.15 / (deltaHeight * 1e-6)
                         self.radarControllerHeaderObj.fClock     = self.fClock
                     if numTaus==0:
                         self.radarControllerHeaderObj.Taus       =  numpy.array(0,'<f4')
                     else:
                         self.radarControllerHeaderObj.Taus       = numpy.array(Taus,'<f4')
                 def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0,
                               dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,
                               nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0,
                               deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0,
                               code=0, nBaud=None, shif_fft=False, flag_dc=False,
                               flag_cspc=False, flag_decode=False, flag_deflip=False):
                     self.processingHeaderObj.dtype             = dtype
                     self.processingHeaderObj.profilesPerBlock  = profilesPerBlock
                     self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile
                     self.processingHeaderObj.nWindows          = nWindows
                     self.processingHeaderObj.processFlags      = processFlags
                     self.processingHeaderObj.nCohInt           = nCohInt
                     self.processingHeaderObj.nIncohInt         = nIncohInt
                     self.processingHeaderObj.totalSpectra      = totalSpectra
                     self.processingHeaderObj.nHeights          = int(nHeights)
                     self.processingHeaderObj.firstHeight       = firstHeight#numpy.array([firstHeight])#firstHeight
                     self.processingHeaderObj.deltaHeight       = deltaHeight#numpy.array([deltaHeight])#deltaHeight
                     self.processingHeaderObj.samplesWin        = nHeights#numpy.array([nHeights])#nHeights
                 def set_BH(self, utc = 0, miliSecond = 0, timeZone = 0):
                     self.basicHeaderObj.utc                    = utc
                     self.basicHeaderObj.miliSecond             = miliSecond
                     self.basicHeaderObj.timeZone               = timeZone
                 def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=32):
                     #self.systemHeaderObj.size           = size
                     self.systemHeaderObj.nSamples       = nSamples
                     self.systemHeaderObj.nProfiles      = nProfiles
                     self.systemHeaderObj.nChannels      = nChannels
                     self.systemHeaderObj.adcResolution  = adcResolution
                     self.systemHeaderObj.pciDioBusWidth = pciDioBusWidth
                 def init_acquisition(self):
                     if self.nFFTPoints != 0:
                         self.incIntFactor = m_nProfilesperBlock/self.nFFTPoints
                         if (self.FixPP_IncInt > self.incIntFactor):
                             self.incIntFactor = self.FixPP_IncInt/ self.incIntFactor
                         elif(self.FixPP_IncInt< self.incIntFactor):
                             print("False alert...")
                     ProfilesperBlock  = self.processingHeaderObj.profilesPerBlock
                     self.timeperblock =int(((self.FixRCP_IPP
                                     *ProfilesperBlock
                                     *self.FixPP_CohInt
                                     *self.incIntFactor)
                                    /150.0)
                                   *0.9
                                   +0.5)
                     # para cada canal
                     self.profiles     =  ProfilesperBlock*self.FixPP_CohInt
                     self.profiles     =  ProfilesperBlock
                     self.Reference    =  int((self.Tau_0-self.AcqH0_0)/(self.AcqDH_0)+0.5)
                     self.BaudWidth    =  int((self.FixRCP_TXA/self.AcqDH_0)/self.Bauds + 0.5 )
                     if (self.BaudWidth==0):
                         self.BaudWidth=1
                 def init_pulse(self,Num_Codes=Num_Codes,Bauds=Bauds,BaudWidth=BaudWidth,Dyn_snCode=Dyn_snCode):
                     Num_Codes   = Num_Codes
                     Bauds       = Bauds
                     BaudWidth   = BaudWidth
                     Dyn_snCode  = Dyn_snCode
                     if Dyn_snCode:
                         print("EXISTE")
                     else:
                         print("No existe")
                     if Dyn_snCode: # if Bauds:
                         pulses         = list(range(0,Num_Codes))
                         num_codes      = Num_Codes
                         for i in range(num_codes):
                             pulse_size = Bauds*BaudWidth
                             pulses[i]  = numpy.zeros(pulse_size)
                             for j in range(Bauds):
                                 for k in range(BaudWidth):
                                     pulses[i][j*BaudWidth+k] = int(Dyn_snCode[i][j]*600)
                     else:
                         print("sin code")
                         pulses     = list(range(1))
                         if self.AcqDH_0>0.149:
                             pulse_size = int(self.FixRCP_TXB/0.15+0.5)
                         else:
                             pulse_size = int((self.FixRCP_TXB/self.AcqDH_0)+0.5) #0.0375
                         pulses[0]  = numpy.ones(pulse_size)
                         pulses     = 600*pulses[0]
                     return pulses,pulse_size
                 def jro_GenerateBlockOfData(self,Samples=Samples,DC_level= DC_level,stdev=stdev,
                                             Reference= Reference,pulses= pulses,
                                             Num_Codes= Num_Codes,pulse_size=pulse_size,
                                             prof_gen= prof_gen,H0 = H0,DH0=DH0,
                                             Adoppler=Adoppler,Fdoppler= Fdoppler,Hdoppler=Hdoppler):
                     Samples    = Samples
                     DC_level   = DC_level
                     stdev      = stdev
                     m_nR       = Reference
                     pulses     = pulses
                     num_codes  = Num_Codes
                     ps         = pulse_size
                     prof_gen   = prof_gen
                     channels   = self.channels
                     H0         = H0
                     DH0        = DH0
                     ippSec     = self.radarControllerHeaderObj.ippSeconds
                     Fdoppler   = self.Fdoppler
                     Hdoppler   = self.Hdoppler
                     Adoppler   = self.Adoppler
                     self.datablock = numpy.zeros([channels,prof_gen,Samples],dtype= numpy.complex64)
                     for i in range(channels):
                         for k in range(prof_gen):
                             #·······················NOISE···············
                             Noise_r    = numpy.random.normal(DC_level,stdev,Samples)
                             Noise_i    = numpy.random.normal(DC_level,stdev,Samples)
                             Noise      = numpy.zeros(Samples,dtype=complex)
                             Noise.real = Noise_r
                             Noise.imag = Noise_i
                             #·······················PULSOS··············
                             Pulso      = numpy.zeros(pulse_size,dtype=complex)
                             Pulso.real =  pulses[k%num_codes]
                             Pulso.imag =  pulses[k%num_codes]
                             #····················· PULSES+NOISE··········
                             InBuffer                    = numpy.zeros(Samples,dtype=complex)
                             InBuffer[m_nR:m_nR+ps]      = Pulso
                             InBuffer                    =  InBuffer+Noise
                             #····················· ANGLE ·······························
                             InBuffer.real[m_nR:m_nR+ps] = InBuffer.real[m_nR:m_nR+ps]*(math.cos( self.fAngle)*5)
                             InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps]*(math.sin( self.fAngle)*5)
                             InBuffer=InBuffer
                             self.datablock[i][k]= InBuffer
                     #················DOPPLER SIGNAL...............................................
                     time_vec   = numpy.linspace(0,(prof_gen-1)*ippSec,int(prof_gen))+self.nReadBlocks*ippSec*prof_gen+(self.nReadFiles-1)*ippSec*prof_gen
                     fd         = Fdoppler #+(600.0/120)*self.nReadBlocks
                     d_signal   = Adoppler*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)
                     #·············Señal con ancho espectral····················
-                    #specw_sig  = numpy.linspace(-149,150,300)
+                    if prof_gen%2==0:
-                    #w          = 8
+                        min = int(prof_gen/2.0-1.0)
-                    #A          = 20
+                        max = int(prof_gen/2.0)
-                    #specw_sig   = specw_sig/w
+                    else:
-                    #specw_sig   = numpy.sinc(specw_sig)
+                        min = int(prof_gen/2.0)
-                    #specw_sig   =  A*numpy.array(specw_sig,dtype=numpy.complex64)
+                        max = int(prof_gen/2.0)
+                    specw_sig  = numpy.linspace(-min,max,prof_gen)
+                    w          = 4
+                    A          = 20
+                    specw_sig   = specw_sig/w
+                    specw_sig   = numpy.sinc(specw_sig)
+                    specw_sig   =  A*numpy.array(specw_sig,dtype=numpy.complex64)
                     #·················· DATABLOCK + DOPPLER····················
                     HD=int(Hdoppler/self.AcqDH_0)
                     for  i in range(12):
                         self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ d_signal# RESULT
                     #·················· DATABLOCK + DOPPLER*Sinc(x)····················
-                    #HD=int(Hdoppler/self.AcqDH_0)
+                    HD=int(Hdoppler/self.AcqDH_0)
-                    #HD=int(HD/2)
+                    HD=int(HD/2)
-                    #for  i in range(12):
+                    for  i in range(12):
-                    #    self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ specw_sig*d_signal# RESULT
+                        self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ specw_sig*d_signal# RESULT
                 def readBlock(self):
                     self.jro_GenerateBlockOfData(Samples= self.samples,DC_level=self.DC_level,
                                                  stdev=self.stdev,Reference= self.Reference,
                                                  pulses = self.pulses,Num_Codes=self.Num_Codes,
                                                  pulse_size=self.pulse_size,prof_gen=self.profiles,
                                                  H0=self.H0,DH0=self.DH0)
                     self.profileIndex   = 0
                     self.flagIsNewFile  = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks  += 1
                     self.nReadBlocks   += 1
                     return 1
                 def getData(self):
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNodata = True
                         return 0
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock         = 0
                     if self.__hasNotDataInBuffer():   # aqui es verdad
                         if not(self.readNextBlock()): # return 1 y por eso el if not salta  a getBasic Header
                             return 0
                         self.getFirstHeader()         # atributo
                     if not self.getByBlock:
                         self.dataOut.flagDataAsBlock = False
                         self.dataOut.data = self.datablock[:, self.profileIndex, :]
                         self.dataOut.profileIndex = self.profileIndex
                         self.profileIndex += 1
                     else:
                         pass
                     self.dataOut.flagNoData = False
                     self.getBasicHeader()
                     self.dataOut.realtime = self.online
                     return self.dataOut.data
                 def setup(self,frequency=49.92e6,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=1000,
                                FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32,
                                FixRCP_TXA = 40, FixRCP_TXB = 50, fAngle = 2.0*math.pi*(1/16),DC_level= 50,
                                stdev= 8,Num_Codes = 1 , Dyn_snCode = None, samples=200,
-                               channels=2,Fdoppler=20,Hdoppler=36,Adoppler=500,nTotalReadFiles=10000,
+                               channels=2,Fdoppler=20,Hdoppler=36,Adoppler=500,
+                               profilesPerBlock=300,dataBlocksPerFile=120,nTotalReadFiles=10000,
                                **kwargs):
                     self.set_kwargs(**kwargs)
                     self.nReadBlocks = 0
                     self.nReadFiles  = 1
                     print('------------------- [Opening file: ] ------------------------------',self.nReadFiles)
                     tmp              = time.time()
                     tmp_utc          = int(tmp)
                     tmp_milisecond   = int((tmp-tmp_utc)*1000)
                     print(" SETUP -basicHeaderObj.utc",datetime.datetime.utcfromtimestamp(tmp))
                     if Dyn_snCode is None:
                         Num_Codes=1
                         Bauds    =1
                     self.set_BH(utc= tmp_utc,miliSecond= tmp_milisecond,timeZone=300 )
                     self.set_RCH( expType=0, nTx=150,ipp=FixRCP_IPP, txA=FixRCP_TXA, txB= FixRCP_TXB,
                              nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0,
                              numTaus=1, line6Function=0, line5Function=0, fClock=None,
                              prePulseBefore=0, prePulseAfter=0,
                              codeType=0, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,
                              flip1=0, flip2=0,Taus=Tau_0)
-                    self.set_PH(dtype=0, blockSize=0, profilesPerBlock=300,
+                    self.set_PH(dtype=0, blockSize=0, profilesPerBlock=profilesPerBlock,
-                                  dataBlocksPerFile=120, nWindows=1, processFlags=numpy.array([1024]), nCohInt=1,
+                                  dataBlocksPerFile=dataBlocksPerFile, nWindows=1, processFlags=numpy.array([1024]), nCohInt=1,
                                   nIncohInt=1, totalSpectra=0, nHeights=samples, firstHeight=AcqH0_0,
                                   deltaHeight=AcqDH_0, samplesWin=samples, spectraComb=0, nCode=0,
                                   code=0, nBaud=None, shif_fft=False, flag_dc=False,
                                   flag_cspc=False, flag_decode=False, flag_deflip=False)
-                    self.set_SH(nSamples=samples, nProfiles=300, nChannels=channels)
+                    self.set_SH(nSamples=samples, nProfiles=profilesPerBlock, nChannels=channels)
                     self.readFirstHeader()
                     self.frequency                      = frequency
                     self.incIntFactor                   = incIntFactor
                     self.nFFTPoints                     = nFFTPoints
                     self.FixPP_IncInt                   = FixPP_IncInt
                     self.FixRCP_IPP                     = FixRCP_IPP
                     self.FixPP_CohInt                   = FixPP_CohInt
                     self.Tau_0                          = Tau_0
                     self.AcqH0_0                        = AcqH0_0
                     self.H0                             = AcqH0_0
                     self.AcqDH_0                        = AcqDH_0
                     self.DH0                            = AcqDH_0
                     self.Bauds                          = Bauds
                     self.FixRCP_TXA                     = FixRCP_TXA
                     self.FixRCP_TXB                     = FixRCP_TXB
                     self.fAngle                         = fAngle
                     self.DC_level                       = DC_level
                     self.stdev                          = stdev
                     self.Num_Codes                      = Num_Codes
                     self.Dyn_snCode                     = Dyn_snCode
                     self.samples                        = samples
                     self.channels                       = channels
                     self.profiles                       = None
                     self.m_nReference                   = None
                     self.Baudwidth                      = None
                     self.Fdoppler                       = Fdoppler
                     self.Hdoppler                       = Hdoppler
                     self.Adoppler                       = Adoppler
                     self.nTotalReadFiles                = int(nTotalReadFiles)
                     print("IPP    ", self.FixRCP_IPP)
                     print("Tau_0  ",self.Tau_0)
                     print("AcqH0_0",self.AcqH0_0)
                     print("samples,window ",self.samples)
                     print("AcqDH_0",AcqDH_0)
                     print("FixRCP_TXA",self.FixRCP_TXA)
                     print("FixRCP_TXB",self.FixRCP_TXB)
                     print("Dyn_snCode",Dyn_snCode)
                     print("Fdoppler", Fdoppler)
                     print("Hdoppler",Hdoppler)
                     print("Vdopplermax",Fdoppler*(3.0e8/self.frequency)/2.0)
                     print("nTotalReadFiles", nTotalReadFiles)
                     self.init_acquisition()
                     self.pulses,self.pulse_size=self.init_pulse(Num_Codes=self.Num_Codes,Bauds=self.Bauds,BaudWidth=self.BaudWidth,Dyn_snCode=Dyn_snCode)
                     print(" [ END ] - SETUP metodo")
                     return
                 def run(self,**kwargs): # metodo propio
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()