Berechnung der räumlichen Verzögerungen pro Jahr in R.

Im Moment habe ich einige Schwierigkeiten bei der Berechnung einer räumlichen Verzögerung in R. Ich weiß, wie man die Verzögerung im raumweiten Format berechnet, kann sie aber nicht in langer Form durchführen, dh ich habe Beobachtungen für die Analyseeinheit wiederholt.

Unten finden Sie einige Scheindaten, um zu veranschaulichen, was ich versuche zu tun. Beginnen wir damit, einige Beobachtungen von Ereignissen zu generieren, an denen ich interessiert bin.

# Create observations
pts<-cbind(set.seed(2014),x=runif(30,1,5),y=runif(30,1,5),
       time=sample(1:5,30,replace=T))
require(sp)
pts<-SpatialPoints(pts)

xund ysind die Koordinaten, während timesie den Zeitraum darstellen, in dem das Ereignis stattfindet. Die Ereignisse müssen zu Polygonen aggregiert werden, die die Analyseeinheit darstellen. In diesem Beispiel sind die Polygone Gitterzellen, und der Einfachheit halber sind die Grenzen über die Zeit festgelegt.

# Observations take place in different areas; create polygons for areas
X<-c(rep(1,5),rep(2,5),rep(3,5),rep(4,5),rep(5,5)) 
Y<-c(rep(seq(1,5,1),5))
df<-data.frame(X,Y)
df$cell<-1:nrow(df) # Grid-cell identifier
require(raster)
coordinates(df)<-~X+Y 
rast<-raster(extent(df),ncol=5,nrow=5)
grid<-rasterize(df,rast,df$cell,FUN=max)
grid<-rasterToPolygons(grid) # Create polygons 

Wir können die Daten nur zeichnen, um einen Überblick über die Verteilung zu erhalten:

Für ein raumweites Format würde ich die räumliche Verzögerung folgendermaßen berechnen:

pointsincell=over(SpatialPolygons(grid@polygons),SpatialPoints(pts),
              returnList=TRUE)
grid$totalcount<-unlist(lapply(pointsincell,length))
require(spdep)
neigh<-poly2nb(grid) # Create neighbour list
weights<-nb2listw(neigh,style="B",zero.policy=TRUE) # Create weights (binary)
grid$spatial.lag<-lag.listw(weights,
                            grid$totalcount,zero.policy=TRUE) # Add to raster

Wie Sie sehen, berücksichtigt dies jedoch nicht die Tatsache, dass die Ereignisse zu unterschiedlichen Zeitpunkten stattfinden. Es aggregiert einfach alles auf die Polygonebene. Jetzt möchte ich diese räumliche Verzögerung unter Berücksichtigung dieser zeitlichen Dimension berechnen, um die Daten in diesem Fall auf der Ebene der Polygonzeit zu aggregieren.

Ich frage mich, ob jemand einen nützlichen Vorschlag hat, wie dies erreicht werden könnte. Was ist die bequemste Methode zur Berechnung räumlicher Verzögerungen im Langformat?

Ich habe mir das spacetimePaket angesehen, konnte es aber nicht anwenden.

Ich denke, der einfachste Weg, dies zu erreichen, besteht darin, Schleifen zu verwenden und die lag.listw () für Ihre Zählvariable für jedes Jahr zu erstellen.

Etwas wie das?

spatlag <- data.frame(id=NULL, time=NULL, lag=NULL)
for (y in sort(unique(data$time))){
  print(y)

Dann setzen Sie in der for-Schleife sowohl die Punkte als auch die Polygone unter und führen die Überlagerung aus. Anschließend fassen Sie die Anzahl der Punkte für jeden Zeitpunkt zusammen und binden sie jeweils zu einem Zeitpunkt an den Spatlag-Datenrahmen.

pointsincell=over(SpatialPolygons(grid@polygons),SpatialPoints(pts),
              returnList=TRUE)
grid$totalcount<-unlist(lapply(pointsincell,length))
require(spdep)
neigh<-poly2nb(grid) # Create neighbour list
weights<-nb2listw(neigh,style="B",zero.policy=TRUE) # Create weights (binary)
grid$spatial.lag<-lag.listw(weights,grid$totalcount,zero.policy=TRUE) # Add to raster
rbind(spatlag, grid)
}

Der obige Code dient nur zur Veranschaulichung. Also: 1. Erstellen Sie einen leeren Datenrahmen zum Speichern der Verzögerungen. 2. Für die Schleife für jeden Zeitpunkt. 3. Erstellen Sie eine Teilmenge für die Punkte, an denen die Zeit der Zeit für den Schleifenlauf entspricht. 4. Überlagern Sie die Punkte auf dem Raster / Polygon. 5. Summieren Sie die Zahl Anzahl der Punkte in jeder Polygonüberlagerung (könnte dplyr zum Aggregieren verwenden) 6. Binden Sie die summierte Anzahl von Punkten an den leeren Datenrahmen.

Dies wäre mit der slagFunktion des splmPakets viel einfacher .

Sagen Sie R, dass data.framees sich um einen Paneldatenrahmen handelt, und arbeiten Sie dann mit dem pseries.

Bitte beachten Sie, dass dies nur mit einem ausgeglichenen Panel funktioniert. Nur um Ihnen ein Beispiel zu geben:

library(plm)
library(splm)
library(spdep)

data("EmplUK", package = "plm")

names(EmplUK)
table(EmplUK$year)
#there should be 140 observations /year, but this is not the case, so tomake it balanced

library(dplyr)
balanced_p<-filter(EmplUK, year>1977 & year<1983)
table (balanced_p$year)
#now it is balanced

firm<-unique(balanced_p$firm)
#I'm using the coordinates (randomly generated) of the firms, but it works also if you use the polygons as you did in your question
coords <- cbind(runif(length(firm),-180,+180), runif(length(firm),-90,+90))
pts_firms<-SpatialPoints(coords)

#now tell R that this is a panel, making sure that the firm id and years are the first two columns of the df
p_data<-pdata.frame(balanced_p)
firm_nb<-knn2nb(knearneigh(pts_firms))
firm_nbwghts<-nb2listw(firm_nb, style="W", zero.policy=T)

#now you can easily create your spatial lag 
#I'm assuming here that the dependent variable is wage! 
p_data$splag<-slag(p_data$wage,firm_nbwghts)

p_data$wageist von Klasse pseries, während firm_nbwghtsalistw

Ich glaube, ich habe eine Methode gefunden, um dies zu tun. Die Ausgabedaten werden in Form eines normalen Datenrahmens geliefert. Es ist ein bisschen ungeschickt, aber es funktioniert.

# Start by creating a panel (CSTS) data frame
grid$cc<-1:nrow(grid)
tiempo<-1:5
polygon<-as.vector(unique(unlist(grid$cc,use.names=FALSE)))

# Loop to create panel data frame
timeCol<-rep(tiempo,length(polygon))
timeCol<-timeCol[order(timeCol)]

polCol <- character()
for(i in tiempo){ 
 row <- polygon
 polCol <- c(polCol, row)
}

df<-data.frame(time=timeCol,nrow=polCol)
df$nrow<-as.numeric(df$nrow)
df<-df[order(df$time,df$nrow),] # Order data frame 

# Assign each point to its corresponding polygon
pts<-SpatialPointsDataFrame(pts,data.frame(pts$time)) # This is a bit clumsy
pts$nrow=over(SpatialPoints(pts),SpatialPolygons(grid@polygons),
              returnlist=TRUE) 

# Aggregate the data per polygon
pts$level<-1
pts.a<-aggregate(level~nrow+time,pts,FUN=sum) # No NA's

# Merge the data
df2<-merge(df,pts.a,all.x=T)
df2[is.na(df2$level),]$level<-0 # Set NA's to 0

# Create contiguity matrix
k<-poly2nb(grid,queen=TRUE) # Create neighbour list
W<-nb2listw(k,style="B",zero.policy=TRUE) # Spatial weights; binary
con<-as.matrix(listw2mat(W)) # Contiguity matrix

# Calculate spatial lag using Kronecker product
N<-length(unique(df2$nrow))
T<-length(unique(df2$time))
ident<-diag(1,nrow=T)
df2$SpatLag<-(ident%x%con)%*%df2$level # Done