def __init__(self,Ionocont,Ionosig,inifile): """ The init function for the fitter take the inputs for the fitter programs. Inputs: DataLags: A dictionary with keys 'Power' 'ACF','RG','Pulses' for the returned value from the RadarData class function processdata. NoiseLags: A dictionary with keys 'Power' 'ACF','RG','Pulses' for the returned value from the RadarData class function processdata. sensdict: The dictionary that holds the sensor info. simparams: The dictionary that hold the specific simulation params""" (self.sensdict,self.simparams) = readconfigfile(inifile) self.Iono = Ionocont self.sig = Ionosig
def __init__(self, Ionocont, Ionosig=None, inifile='default.ini'): """ The init function for the fitter take the inputs for the fitter programs. Inputs: DataLags: A dictionary with keys 'Power' 'ACF','RG','Pulses' for the returned value from the RadarData class function processdata. NoiseLags: A dictionary with keys 'Power' 'ACF','RG','Pulses' for the returned value from the RadarData class function processdata. sensdict: The dictionary that holds the sensor info. simparams: The dictionary that hold the specific simulation params""" (self.sensdict, self.simparams) = readconfigfile(inifile) self.Iono = Ionocont self.sig = Ionosig
def main(): """Testing function""" t1 = time.time() curpath = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) testpath = os.path.join(os.path.split(curpath)[0],'Testdata') inifile = os.path.join(testpath,'PFISRExample.pickle') (sensdict,simparams) = readconfigfile(inifile) testh5 = os.path.join(testpath,'testiono.h5') ioncont = IonoContainer.readh5(testh5) outfile = os.path.join(testpath,'testionospec.h5') ioncont.makespectruminstanceopen(specfunctions.ISRSspecmake,sensdict, simparams['numpoints']).saveh5(outfile) radardata = RadarDataFile({0.0:outfile},inifile,testpath) ionoout = radardata.processdataiono() ionoout.saveh5(os.path.join(testpath,'lags.h5')) t2 = time.time() print(t2-t1)
def __init__(self,ionoin,configfile): r2d = 180.0/sp.pi d2r = sp.pi/180.0 (sensdict,simparams) = readconfigfile(configfile) nt = ionoin.Time_Vector.shape[0] nloc = ionoin.Sphere_Coords.shape[0] #Input location self.Cart_Coords_in = ionoin.Cart_Coords self.Sphere_Coords_In = ionoin.Sphere_Coords, self.Time_In = ionoin.Time_Vector self.Cart_Coords_In_Rep = sp.tile(ionoin.Cart_Coords,(nt,1)) self.Sphere_Coords_In_Rep = sp.tile(ionoin.Sphere_Coords,(nt,1)) self.Time_In_Rep = sp.repeat(ionoin.Time_Vector,nloc,axis=0) #output locations rng_vec2 = simparams['Rangegatesfinal'] nrgout = len(rng_vec2) angles = simparams['angles'] nang =len(angles) ang_data = sp.array([[iout[0],iout[1]] for iout in angles]) rng_all = sp.tile(rng_vec2,(nang)) ang_all = sp.repeat(ang_data,nrgout,axis=0) nlocout = nang*nrgout ntout = len(simparams['Timevec']) self.Sphere_Coords_Out = sp.column_stack((rng_all,ang_all)) (R_vec,Az_vec,El_vec) = (self.Sphere_Coords_Out[:,0],self.Sphere_Coords_Out[:,1],self.Sphere_Coords_Out[:,2]) xvecmult = sp.cos(Az_vec*d2r)*sp.cos(El_vec*d2r) yvecmult = sp.sin(Az_vec*d2r)*sp.cos(El_vec*d2r) zvecmult = sp.sin(El_vec*d2r) X_vec = R_vec*xvecmult Y_vec = R_vec*yvecmult Z_vec = R_vec*zvecmult self.Cart_Coords_Out = sp.column_stack((X_vec,Y_vec,Z_vec)) self.Time_Out = simparams['Timevec'] self.Time_Out_Rep =sp.repeat(simparams['Timevec'],nlocout,axis=0) self.Sphere_Coords_Out_Rep =sp.tile(self.Sphere_Coords_Out,(ntout,1)) self.RSTMat = makematPA(ionoin.Sphere_Coords,ionoin.Time_Vector)
def __init__(self,Ionodict,inifile, outdir,outfilelist=None): """This function will create an instance of the RadarData class. It will take in the values and create the class and make raw IQ data. Inputs: sensdict - A dictionary of sensor parameters angles - A list of tuples which the first position is the az angle and the second position is the el angle. IPP - The interpulse period in seconds represented as a float. Tint - The integration time in seconds as a float. This will be the integration time of all of the beams. time_lim - The length of time of the simulation the number of time points will be calculated. pulse - A numpy array that represents the pulse shape. rng_lims - A numpy array of length 2 that holds the min and max range that the radar will cover.""" (sensdict,simparams) = readconfigfile(inifile) self.simparams = simparams N_angles = len(self.simparams['angles']) NNs = self.simparams['NNs'] self.sensdict = sensdict Npall = sp.floor(self.simparams['TimeLim']/self.simparams['IPP']) Npall = sp.floor(Npall/N_angles)*N_angles Np = Npall/N_angles print "All spectrums created already" filetimes = Ionodict.keys() filetimes.sort() ftimes = sp.array(filetimes) simdtype = self.simparams['dtype'] pulsetimes = sp.arange(Npall)*self.simparams['IPP'] pulsefile = sp.array([sp.where(itimes-ftimes>=0)[0][-1] for itimes in pulsetimes]) # differentiate between phased arrays and dish antennas if sensdict['Name'].lower() in ['risr','pfisr']: beams = sp.tile(sp.arange(N_angles),Npall/N_angles) else: # for dish arrays brate = simparams['beamrate'] beams2 = sp.repeat(sp.arange(N_angles),brate) beam3 = sp.concatenate((beams2,beams2[:-1,::-1])) beams = sp.tile(beam3,Npall/len(beam3)) pulsen = sp.repeat(sp.arange(Np),N_angles) pt_list = [] pb_list = [] pn_list = [] fname_list = [] self.datadir = outdir self.maindir = os.path.dirname(os.path.abspath(outdir)) self.procdir =os.path.join(self.maindir,'ACF') self.procdir if outfilelist is None: print('\nData Now being created.') Noisepwr = v_Boltz*sensdict['Tsys']*sensdict['BandWidth'] self.outfilelist = [] for ifn, ifilet in enumerate(filetimes): outdict = {} ifile = Ionodict[ifilet] print('\tData from {0:d} of {1:d} being processed Name: {2:s}.'.format(ifn,len(filetimes),os.path.split(ifile)[1])) curcontainer = IonoContainer.readh5(ifile) pnts = pulsefile==ifn pt =pulsetimes[pnts] pb = beams[pnts] pn = pulsen[pnts].astype(int) (rawdata,outdict['SpecsUsed'])= self.__makeTime__(pt,curcontainer.Time_Vector, curcontainer.Sphere_Coords, curcontainer.Param_List,pb) Noise = sp.sqrt(Noisepwr/2)*(sp.random.randn(*rawdata.shape).astype(simdtype)+ 1j*sp.random.randn(*rawdata.shape).astype(simdtype)) outdict['AddedNoise'] =Noise outdict['RawData'] = rawdata+Noise outdict['RawDatanonoise'] = rawdata outdict['NoiseData'] = sp.sqrt(Noisepwr/2)*(sp.random.randn(len(pn),NNs).astype(simdtype)+ 1j*sp.random.randn(len(pn),NNs).astype(simdtype)) outdict['Pulses']=pn outdict['Beams']=pb outdict['Time'] = pt fname = '{0:d} RawData.h5'.format(ifn) newfn = os.path.join(self.datadir,fname) self.outfilelist.append(newfn) dict2h5(newfn,outdict) #Listing info pt_list.append(pt) pb_list.append(pb) pn_list.append(pn) fname_list.append(fname) infodict = {'Files':fname_list,'Time':pt_list,'Beams':pb_list,'Pulses':pn_list} dict2h5(os.path.join(outdir,'INFO.h5'),infodict) else: self.outfilelist=outfilelist
def __init__(self, ionoin, configfile, timein=None, mattype='matrix'): """ This will create the RadarSpaceTimeOperator object. Inputs ionoin - The input ionocontainer. This can be either an string that is a ionocontainer file, a list of ionocontainer objects or a list a strings to ionocontainer files config - The ini file that used to set up the simulation. timein - A Ntx2 numpy array of times. RSTOPinv - The inverse operator object. invmat - The inverse matrix to the original operator. """ mattype = mattype.lower() accepttypes = ['matrix', 'sim', 'real'] if not mattype in accepttypes: raise ValueError('Matrix type can only be {0}'.format( ', '.join(accepttypes))) d2r = sp.pi / 180.0 (sensdict, simparams) = readconfigfile(configfile) # determine if the input ionocontainer is a string, a list of strings or a list of ionocontainers. ionoin = makeionocombined(ionoin) #Input location self.Cart_Coords_In = ionoin.Cart_Coords self.Sphere_Coords_In = ionoin.Sphere_Coords # Set the input times if timein is None: self.Time_In = ionoin.Time_Vector else: self.Time_In = timein #Create an array of output location based off of the inputs rng_vec2 = simparams['Rangegatesfinal'] nrgout = len(rng_vec2) angles = simparams['angles'] nang = len(angles) ang_data = sp.array([[iout[0], iout[1]] for iout in angles]) rng_all = sp.repeat(rng_vec2, (nang), axis=0) ang_all = sp.tile(ang_data, (nrgout, 1)) self.Sphere_Coords_Out = sp.column_stack((rng_all, ang_all)) (R_vec, Az_vec, El_vec) = (self.Sphere_Coords_Out[:, 0], self.Sphere_Coords_Out[:, 1], self.Sphere_Coords_Out[:, 2]) xvecmult = sp.sin(Az_vec * d2r) * sp.cos(El_vec * d2r) yvecmult = sp.cos(Az_vec * d2r) * sp.cos(El_vec * d2r) zvecmult = sp.sin(El_vec * d2r) X_vec = R_vec * xvecmult Y_vec = R_vec * yvecmult Z_vec = R_vec * zvecmult self.Cart_Coords_Out = sp.column_stack((X_vec, Y_vec, Z_vec)) self.Time_Out = sp.column_stack( (simparams['Timevec'], simparams['Timevec'] + simparams['Tint'])) + self.Time_In[0, 0] self.simparams = simparams self.sensdict = sensdict self.lagmat = self.simparams['amb_dict']['WttMatrix'] self.mattype = mattype # create the matrix (self.RSTMat, self.overlaps, self.blocklocs) = makematPA(ionoin.Sphere_Coords, ionoin.Cart_Coords, ionoin.Time_Vector, configfile, ionoin.Velocity, mattype)
def makematPA(Sphere_Coords, Cart_Coords, timein, configfile, vel=None, mattype='matrix'): """Make a Ntimeout*Nbeam*Nrng x Ntime*Nloc sparse matrix for the space time operator. The output space will have range repeated first, then beams then time. The coordinates will be [t0,b0,r0],[t0,b0,r1],[t0,b0,r2],... [t0,b1,r0],[t0,b1,r1], ... [t1,b0,r0],[t1,b0,r1],...[t1,b1,r0]... Inputs Sphere_Coords - A Nlocx3 array of the spherical coordinates of the input data. timein - A Ntbegx2 numpy array with the start and stop times of the input data. configfile - The ini file used for the simulation configuration. vel - A NlocxNtx3 numpy array of velocity. Outputs outmat - A list of matricies or a single matrix that is the forward between physical space to the discrete samples space of the radar. blocks - A tuple that holds the number of block matricies in overall forward operator. blocksize - A tuple that holds the shape of the outmatrix size. blockloc - An Ntout x Ntbeg array that holds the corresponding spatial forward model. """ # (sensdict, simparams) = readconfigfile(configfile) timeout = simparams['Timevec'] Tint = simparams['Tint'] timeout = sp.column_stack((timeout, timeout + Tint)) + timein[0, 0] rng_bin = sensdict['t_s'] * v_C_0 * 1e-3 / 2. angles = simparams['angles'] Nbeams = len(angles) rng_vec2 = simparams['Rangegatesfinal'] nrgout = len(rng_vec2) pulse = simparams['Pulse'] p_samps = pulse.shape[0] rng_len = p_samps * rng_bin Nlocbeg = Cart_Coords.shape[0] Nlocout = Nbeams * nrgout Ntbeg = len(timein) Ntout = len(timeout) if vel is None: vel = sp.zeros((Nlocbeg, Ntbeg, 3)) # determine the overlaps # change blockloc_in = [[i * Nlocbeg, (i + 1) * Nlocbeg] for i in range(Ntout)] blockloc_out = [[i * Nlocout, (i + 1) * Nlocout] for i in range(Ntout)] blockloc = [blockloc_in, blockloc_out] # set up blocks blocksize = (Ntout * Nbeams * nrgout, Nlocbeg * Ntout) # make the matrix outmat = sp.sparse.lil_matrix(blocksize, dtype=sp.float64) overlaps = {} if mattype.lower() == 'real': cor_ratio = .5 else: cor_ratio = 1. for iton, ito in enumerate(timeout): overlaps[iton] = [] firstone = True for ix, x in enumerate(timein): if (x[0] + 1 < ito[1] or ix == (Ntbeg - 1)) and x[1] - 1 > ito[0]: # find the end of the data if ix == Ntbeg - 1: enp = ito[1] else: enp = sp.minimum(ito[1], x[1]) stp = sp.maximum(x[0], ito[0]) curvel = vel[:, 0] * 1e-3 # XXX This is just a quick fix curvel[:, -1] = 0 if firstone: firstone = False t_0 = stp.copy() curdiff = sp.zeros_like(vel[:, ix]) curdiff2 = curdiff + float(enp - stp) * curvel else: T_1 = float(x[0] - t_0) t_0 = stp.copy() curdiff = curdiff2 curdiff2 = curdiff + float(enp - stp) * curvel #find amount of time for overlap ratio = float(enp - stp) / Tint # set up new coordinate system # The thee types of coordinates are as follows # The matrix type assumes that the matrix will be applied to the data. # The sim type if mattype.lower() == 'matrix': newcoorsds1 = cart2sphere(Cart_Coords) newcoorsds2 = cart2sphere(Cart_Coords) elif mattype.lower == 'real': newcoorsds1 = cart2sphere(Cart_Coords + curdiff) newcoorsds2 = cart2sphere(Cart_Coords + curdiff2) else: newcoorsds1 = cart2sphere(Cart_Coords + curdiff) newcoorsds2 = cart2sphere(Cart_Coords + curdiff) overlaps[iton].append([ix, ratio, newcoorsds1, newcoorsds2]) # make the matrix for iton, ito in enumerate(timeout): cur_over = overlaps[iton] # if mattype=='matrix': # cur_over=[cur_over[0]] # cur_over[0][1]=1. beamnorm = sp.ones(Nbeams * nrgout) for it_in, it_info in enumerate(cur_over): print('\t Making Input time {0:d} of {1:d}'.format( it_in, len(cur_over))) cur_it, cur_ratio, Sp1, Sp2 = it_info # if mattype.lower()=='sim': # cur_ratio=1. rho1 = Sp1[:, 0] Az1 = Sp1[:, 1] El1 = Sp1[:, 2] rho2 = Sp2[:, 0] Az2 = Sp2[:, 1] El2 = Sp2[:, 2] # get the weights weights1 = { ibn: sensdict['ArrayFunc'](Az1, El1, ib[0], ib[1], sensdict['Angleoffset']) for ibn, ib in enumerate(angles) } weights2 = { ibn: sensdict['ArrayFunc'](Az2, El2, ib[0], ib[1], sensdict['Angleoffset']) for ibn, ib in enumerate(angles) } for ibn in range(Nbeams): print('\t\t Making Beam {0:d} of {1:d}'.format(ibn, Nbeams)) weight1 = weights1[ibn] weight2 = weights2[ibn] for isamp in range(nrgout): # make the row irow = ibn + isamp * Nbeams + Nbeams * nrgout * iton range_g = rng_vec2[isamp] rnglims = [range_g - rng_len / 2., range_g + rng_len / 2.] # assume centered lag product. rangelog = ((rho1 >= rnglims[0]) & (rho1 < rnglims[1])) # This is a nearest neighbors interpolation for the spectrums in the range domain if sp.sum(rangelog) == 0: minrng = sp.argmin(sp.absolute(range_g - rho1)) rangelog[minrng] = True #create the weights and weight location based on the beams pattern. weight_cur = weight1[rangelog] # fix averaging problems if it_in == 0: beamnorm[ibn + isamp * Nbeams] = weight_cur.sum() weight_cur = weight_cur / beamnorm[ibn + isamp * Nbeams] icols = sp.where(rangelog)[0] + Nlocbeg * iton # icols = sp.where(rangelog)[0] + Nlocbeg*cur_it weights_final = weight_cur * range_g**2 / rho1[rangelog]**2 outmat[ irow, icols] = weights_final * cur_ratio * cor_ratio + outmat[ irow, icols] if mattype.lower() == 'real': # assume centered lag product. rangelog = ((rho2 >= rnglims[0]) & (rho2 < rnglims[1])) # This is a nearest neighbors interpolation for the spectrums in the range domain if sp.sum(rangelog) == 0: minrng = sp.argmin(sp.absolute(range_g - rho2)) rangelog[minrng] = True #create the weights and weight location based on the beams pattern. weight_cur = weight2[rangelog] weight_cur = weight_cur // beamnorm[ibn + isamp * Nbeams] # icols = sp.where(rangelog)[0]+ Nlocbeg*cur_it icols = sp.where(rangelog)[0] + Nlocbeg * iton weights_final = weight_cur * range_g**2 / rho2[ rangelog]**2 outmat[ irow, icols] = weights_final * cur_ratio * cor_ratio + outmat[ irow, icols] return (outmat, overlaps, blockloc)
def __init__(self,Ionodict,inifile, outdir,outfilelist=None): """This function will create an instance of the RadarData class. It will take in the values and create the class and make raw IQ data. Inputs: sensdict - A dictionary of sensor parameters angles - A list of tuples which the first position is the az angle and the second position is the el angle. IPP - The interpulse period in seconds represented as a float. Tint - The integration time in seconds as a float. This will be the integration time of all of the beams. time_lim - The length of time of the simulation the number of time points will be calculated. pulse - A numpy array that represents the pulse shape. rng_lims - A numpy array of length 2 that holds the min and max range that the radar will cover.""" (sensdict,simparams) = readconfigfile(inifile) self.simparams = simparams N_angles = len(self.simparams['angles']) NNs = int(self.simparams['NNs']) self.sensdict = sensdict Npall = sp.floor(self.simparams['TimeLim']/self.simparams['IPP']) Npall = sp.floor(Npall/N_angles)*N_angles Np = Npall/N_angles print "All spectrums created already" filetimes = Ionodict.keys() filetimes.sort() ftimes = sp.array(filetimes) simdtype = self.simparams['dtype'] pulsetimes = sp.arange(Npall)*self.simparams['IPP'] +ftimes.min() pulsefile = sp.array([sp.where(itimes-ftimes>=0)[0][-1] for itimes in pulsetimes]) # differentiate between phased arrays and dish antennas if sensdict['Name'].lower() in ['risr','pfisr','risr-n']: beams = sp.tile(sp.arange(N_angles),Npall/N_angles) else: # for dish arrays brate = simparams['beamrate'] beams2 = sp.repeat(sp.arange(N_angles),brate) beam3 = sp.concatenate((beams2,beams2[::-1])) ntile = sp.ceil(Npall/len(beam3)) leftover = Npall-ntile*len(beam3) if ntile>0: beams = sp.tile(beam3,ntile) beams=sp.concatenate((beams,beam3[:leftover])) else: beams=beam3[:leftover] pulsen = sp.repeat(sp.arange(Np),N_angles) pt_list = [] pb_list = [] pn_list = [] fname_list = [] self.datadir = outdir self.maindir = os.path.dirname(os.path.abspath(outdir)) self.procdir =os.path.join(self.maindir,'ACF') if outfilelist is None: print('\nData Now being created.') Noisepwr = v_Boltz*sensdict['Tsys']*sensdict['BandWidth'] self.outfilelist = [] for ifn, ifilet in enumerate(filetimes): outdict = {} ifile = Ionodict[ifilet] print('\tData from {0:d} of {1:d} being processed Name: {2:s}.'.format(ifn,len(filetimes), os.path.split(ifile)[1])) curcontainer = IonoContainer.readh5(ifile) if ifn==0: self.timeoffset=curcontainer.Time_Vector[0,0] pnts = pulsefile==ifn pt =pulsetimes[pnts] pb = beams[pnts] pn = pulsen[pnts].astype(int) rawdata= self.__makeTime__(pt,curcontainer.Time_Vector, curcontainer.Sphere_Coords, curcontainer.Param_List,pb) Noise = sp.sqrt(Noisepwr/2)*(sp.random.randn(*rawdata.shape).astype(simdtype)+ 1j*sp.random.randn(*rawdata.shape).astype(simdtype)) outdict['AddedNoise'] =Noise outdict['RawData'] = rawdata+Noise outdict['RawDatanonoise'] = rawdata outdict['NoiseData'] = sp.sqrt(Noisepwr/2)*(sp.random.randn(len(pn),NNs).astype(simdtype)+ 1j*sp.random.randn(len(pn),NNs).astype(simdtype)) outdict['Pulses']=pn outdict['Beams']=pb outdict['Time'] = pt fname = '{0:d} RawData.h5'.format(ifn) newfn = os.path.join(self.datadir,fname) self.outfilelist.append(newfn) dict2h5(newfn,outdict) #Listing info pt_list.append(pt) pb_list.append(pb) pn_list.append(pn) fname_list.append(fname) infodict = {'Files':fname_list,'Time':pt_list,'Beams':pb_list,'Pulses':pn_list} dict2h5(os.path.join(outdir,'INFO.h5'),infodict) else: infodict= h52dict(os.path.join(outdir,'INFO.h5')) alltime=sp.hstack(infodict['Time']) self.timeoffset=alltime.min() self.outfilelist=outfilelist
def makematPA(Sphere_Coords,timein,configfile): """Make a Ntimeout*Nbeam*Nrng x Ntime*Nloc matrix. The output space will have range repeated first, then beams then time. The coordinates will be [t0,b0,r0],[t0,b0,r1],[t0,b0,r2],... [t0,b1,r0],[t0,b1,r1], ... [t1,b0,r0],[t1,b0,r1],...[t1,b1,r0]...""" # (sensdict,simparams) = readconfigfile(configfile) timeout = simparams['Timevec'] Tint = simparams['Tint'] timeout = sp.column_stack((timeout,timeout+Tint)) fullmat = True rng_vec = simparams['Rangegates'] rng_bin=sensdict['t_s']*v_C_0/1000.0 sumrule = simparams['SUMRULE'] # minrgbin = -sumrule[0].min() maxrgbin = len(rng_vec)-sumrule[1].max() minrg = minrgbin*rng_bin maxrg = maxrgbin*rng_bin angles = simparams['angles'] Nbeams = len(angles) rho = Sphere_Coords[:,0] Az = Sphere_Coords[:,1] El = Sphere_Coords[:,2] rng_vec2 = simparams['Rangegatesfinal'] nrgout = len(rng_vec2) Nlocbeg = len(rho) Ntbeg = len(timein) Ntout = len(timeout) if fullmat: outmat = sp.matrix(sp.zeros((Ntout*Nbeams*nrgout,Nlocbeg*Ntbeg))) else: outmat = sp.sparse((Ntout*Nbeams*nrgout,Nlocbeg*Ntbeg),dype =sp.float64) weights = {ibn:sensdict['ArrayFunc'](Az,El,ib[0],ib[1],sensdict['Angleoffset']) for ibn, ib in enumerate(angles)} for iton,ito in enumerate(timeout): overlaps = sp.array([getOverlap(ito,x) for x in timein]) weights_time = overlaps/overlaps.sum() itpnts = sp.where(weights_time>0)[0] # usually the matrix size is nbeamsxnrange for ibn in range(Nbeams): print('\t\t Making Beam {0:d} of {1:d}'.format(ibn,Nbeams)) weight = weights[ibn] for isamp in range(nrgout): # make the row irow = isamp+ibn*nrgout+iton*nrgout*Nbeams range_g = rng_vec2[isamp] rnglims = [range_g-minrg,range_g+maxrg] rangelog = sp.argwhere((rho>=rnglims[0])&(rho<rnglims[1])) # This is a nearest neighbors interpolation for the spectrums in the range domain if sp.sum(rangelog)==0: minrng = sp.argmin(sp.absolute(range_g-rho)) rangelog[minrng] = True #create the weights and weight location based on the beams pattern. weight_cur =weight[rangelog[:,0]] weight_cur = weight_cur/weight_cur.sum() weight_loc = sp.where(rangelog[:,0])[0] w_loc_rep = sp.tile(weight_loc,len(itpnts)) t_loc_rep = sp.repeat(itpnts,len(weight_loc)) icols = t_loc_rep*Nlocbeg+w_loc_rep weights_final = weights_time[t_loc_rep]*weight_cur[w_loc_rep]*range_g**2/rho[w_loc_rep]**2 outmat[irow,icols] = weights_final return(outmat)