#if(require(gdata)==FALSE)install.packages("gdata",contriburl = contrib.url("http://cran.us.r-project.org"))

##################################################### VARIABLES ###################################################################################
# FORMATO   nota: prima di importare l'infofile elimina tutte le colonne vuote dopo l'ultima utilizzata, a volte capita che importa anche colonne di NA
# INFOFILE: la colonna con i codici nell'infofile in excel deve essere formattata come TESTO altrimenti si perdono gli zeri all'inizio.
#           la lista nell'infofile DEVE avere una prima fila di intestazione, e le colonne disposte nell'ordine: 
#						codice/nome stazione/provincia/lat/lon/altezza
#           (le due colonne lat e long DEVONO essere espresse in gradi decimali, mentre le altre colonne possono chiamarsi come si vuole e la provincia e l'altezza possono anche essere vuote)
# nome e cartella del infofile .xls con l'elenco delle serie:
#dir_infofile="C:/nicola/precipitaciones/weather_types/Validation series 1864-2005/database_Madrid_Lisboa_Valencia.xls" 
#dir_infofile="C:/nicola/precipitaciones/weather_types/datos_caudales_portugal/infofile.xls" 
#dir_infofile="C:/nicola/precipitaciones/prec_mensuales_Iberia/infofile_Iberia_sin_Ceuta_y_con_Lisboa.xls" # carico questo database invece del "infofile_Iberia_sin_-999.xls" anche se ci sono alcune stazioni con -999 nel 1945, 1946 e 1947 perche' tanto il periodo comune di intersezione con il database Cost733 dei WTs e' il 1957-2002
#dir_infofile="C:/nicola/precipitaciones/weather_types/contaminantes/infofile_ingresos_hospital.xls"
#dir_infofile="C:/nicola/precipitaciones/prec_mensuales_Spain/Mopredas_1915-2003/6) info_mopredas_1915-2005_full_para_R.xls" 
dir_infofile="C:/nicola/temperaturas/WTs and temp/infofile.xls"

# FORMATO	Nel file .txt o .csv dei dati con la prec.mensile ci possono essere anche mesi con -999 : in questo caso riesce cmq a fare la regressione
# DATABASE  e a calcolare gli indici di errore (togliendo gli anni mancanti) e a interpolare, solo per fare il variogramma deve togliere i -999 
# PRECIP:	e sostituirli con il valore medio mensile della serie su tutti gli anni.
# 			Ogni serie puo' cominciare e/o finire anche con un anno diverso delle altre, l'importante e' che non ci siano serie senza anni al loro interno!!!
#			(cioe' ci deve essere una fila per ogni anno di dati, anche se e' piena solo di -999)
# 			Anche i file con i tipi di tempo (WTs) di ogni classificazione possono iniziare e finire con date diverse dal database di prec.,
# 			ma ricordati che per fare la regressione bisogna scegliere un periodo comune sempre compreso in tutte le classificazioni.
#			il file puo'avere o meno una prima fila di intestazione con nomi a piacere, ma le colonne DEVONO seguire questo ordine:
#						codice anno gen feb mar ... dic
#			i valori della prec.possono essere espressi in mm. o in decimi di mm.
# 			nota che le serie in infofile possono avere un ordine diverso da quello sul file di dati, basta solo che ne' in infofile ne' in dati vi siano serie ripetute due o piu'volte.
# nome e cartella del file .txt con il database delle serie di prec.mensile:
#dir_datos="C:/nicola/precipitaciones/weather_types/Validation series 1864-2005/database_Madrid_Lisboa_Valencia.txt" # ci sono alcuni -999 quindi non si puo' interpolare
#dir_datos="C:/nicola/precipitaciones/weather_types/datos_caudales_portugal/datos_1956-2006.txt"
#dir_datos="C:/nicola/precipitaciones/prec_mensuales_Iberia/datos_Iberia_sin_Ceuta_y_con_Lisboa.txt"
#dir_datos="C:/nicola/precipitaciones/weather_types/contaminantes/2) datos_ingresos_hospital.txt"
#dir_datos="C:/nicola/precipitaciones/prec_mensuales_Spain/Mopredas_1915-2003/base_datos_origen_1850-2005.csv"
dir_datos="C:/nicola/temperaturas/WTs and temp/datos.txt"

header_datos=TRUE # specifica se i dati hanno o meno una prima fila con l'intestazione (vale TRUE per il database MOPREDASP)
piu_1=FALSE # vale true se nel file di dati di prec <dir_datos> si e' aggiunto 1 a tutti i valori mensili di prec per evitare gli zeri
dec_mm=TRUE  # vale true se la prec.e'espressa in decimi di mm, false altrimenti
remove_2006=FALSE # vale true per togliere l'anno 2006 dal database (solo per il database MOPREDASP)

##### Parametri Weather Types (WTs):
# cartella con tutti i file con le classificazioni di tipi di tempo usate: (nel formato anno/mese/giorno/WT)
dir_WT="C:/nicola/precipitaciones/weather_types/26 WTs from begin year to end"
cla.rif=3 # numero corrispondente alla classificazione dei WTs presa come riferimento per fare la regressione e le altre analisi
		   #(1= 20th C.Reanalysis, 2= EMULATE, 3=NCEP, 4=NCEP con 10 WTs, 5= EMULATE con downscaling fatto da me con S y E corretti; l'ordine e'lo stesso che hanno i file di dati nella cartella dir_WT)
		   # occhio che se la classificazione non comincia con il primo di gennaio o non termina con il 31 di dicembre, viene tolto il primo e/o l'ultimo anno di dati
weekly=FALSE # vale fa?se se i i conteggi dei WT in monthlyWT vengono fatti per mese, true per settimane
years.filtro=30 #50 # numero di anni per lo smoothing del filtro gaussiano nella Mappa 6 delle frequenze dei WTs
contaminantes=FALSE # vale true se INVECE dei WTs si carica il file con i 5 contaminanti indicato sotto:
contam="C:/nicola/precipitaciones/weather_types/contaminantes/5_contaminantes.txt"
		   
# nell'ultima colonna di dati, quella con i WTs, devono essere numerati in modo che ad ogni numero intero in ordine crescente corrisponda il seguente WT:
# "NE","E","SE","S","SW","W","NW","N","C","C.NE","C.E","C.SE","C.S","C.SW","C.W","C.NW","C.N","A","A.NE","A.E","A.SE","A.S","A.SW","A.W","A.NW","A.N"
# non importa che i numeri vadano proprio da 1 a 26, basta che al numero piu'piccolo corrisponda il tipo NE, al secondo piu' piccolo l'E, ecc.ecc.
begin.analisi=1950 #1915 #1950 #1948 #1 #1850 # anno di inizio per i calcoli della frequenza mensile dei WTs (puo'essere diverso rispetto al periodo della regressione, basta che ci siano i dati dei WTs)
end.analisi=2010 #1949 #2003 #574 # anno di fine per i calcoli della frequenza dei WTs

##### Parametri Classificazione Tipi di Tempo con il Metodo di Lamb:
SLP_to_WTs=FALSE  # se true, prima di importare i file con i tipi di tempo, importa UN file con i dati di pressione SLP nel formato seguente:
				#     anno/mese/giorno/daily pression dei pixel lungo la longitudine [1 giorno uguale per ogni num.di pixel lungo la latitud]
				# dalla directory sotto indicata e li converte in un file con tipi di tempo, che salva sotto 'dir_WT/SLP_to_WTs.txt'.
				
# nome file input con i dati SLP nel formato corretto (detto normalizzato o standard nel testo):
#file.SLP="C:/nicola/pressure/database_emulate/2) emulate_normalizado_1850-2003.txt"  
file.SLP="C:/nicola/pressure/database_NCEP_Reanalysis/3) database per R/NCEP_formato_standard_1970-2012.txt"  # occhio che è piu di un GB di dati!!!
#file.SLP="C:/nicola/pressure/database_NCEP_Reanalysis/3) database per R/NCEP_formato_standard_2000.txt" 
#file.SLP="C:/nicola/pressure/database_NCEP_Reanalysis/3) database per R/NCEP_formato_standard_from_2000_to_october_2012.txt" # solo dal 2000 al 2012

npx.ver=73 #10 per EMULATE, 73 per NCAR/NCEP # numero di pixel in verticale [latitud] della griglia in file.SLP (il numero di pixel in orizzontale non ci serve)
		     #(coincide con il numero di file per ogni mappa raster, ovvero dei valori possibili di latitudine)
deg=2.5 #5 per EMULATE, 2.5 per NCAR # risoluzione del grid di SLP in gradi
lat.central=40 #latitudine in gradi dei 4 pixel della fila centrale (per il calcolo dei numeri nelle formule dei 6 indici geostrofici).
				# 40 per Madrid, 42.5 per Santander e Zaragoza, 45 per Torino
			     # nota che se si sposta il grid in senso longitudinale, i 6 indici geostrofici non cambiano.
lat.2nd.row=lat.central+5 #45 #47.5 # 45 # latitudine in gradi dei 4 pixel della fila sopra quella centrale (di solito 5 gradi piu' a nord)
angolo.basso.sinistra=c(-70, 25) # coordinate angolo in basso a sinistra di ogni griglia (solo per visualizzare le mappe finali)

# posizione dei 16 pixel su cui si basa il calcolo dei WTs all'interno del grid in file.SLP
#(contando sempre dall'alto verso il basso e da sinistra verso destra):
#lon.16p=c(13,15,11,13,15,17,11,13,15,17,11,13,15,17,13,15) # per il database EMULATE centrato sulla IP
#lat.16p=c(5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9) # per il database EMULATE centrato sulla IP
lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1) # per il database NCAR centrato sulla IP (in -5?,40?)
lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25) # per il database NCAR centrato sulla IP 
#lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1) # per il database NCAR centrato su Santander (+1 pixel verso nord)
#lat.16p=c(16,16,18,18,18,18,20,20,20,20,22,22,22,22,24,24) # per il database NCAR centrato su Santander
#lon.16p=c(143,3,139,143,3,7,139,143,3,7,139,143,3,7,143,3) # per il database NCAR centrato su Zaragoza (+2 pixel verso est e +1 verso nord)
#lat.16p=c(16,16,18,18,18,18,20,20,20,20,22,22,22,22,24,24) # per il database NCAR centrato su Zaragoza

#lon.16p=c(2,6,142,2,6,10,142,2,6,10,142,2,6,10,2,6) # per il database NCAR centrato su Torino
#lat.16p=c(15,15,17,17,17,17,19,19,19,19,21,21,21,21,23,23) # per il database NCAR centrato su Torino

# nome file output dove salvare i 26 WTs in formato numerico da 1 a 26(anno/mese/giorno/WT):
output.WTs="C:/nicola/precipitaciones/weather_types/26 WTs from begin year to end/NCEP.txt"
#output.WTs="C:/nicola/precipitaciones/weather_types/26 WTs from begin year to end/WTs_from_EMULATE_nic.txt"

# per esempio, il grid NCEP e' di 144*73 pixel a risoluzione 2.5 gradi, partendo da 90 gr. nord 0 est andando verso est e sud.
# la long e lat dei 16 punti di grid su cui si basa il calcolo dei WTs per la IP e' sempre pari a:
#
#			 		p1: (-10?,50?)		p2: (0?,50?)
# p3: (-20?,45?)	p4: (-10?,45?)  	p5: (0?,45?)	p6: (10?,45?)
# p7: (-20?,40?)	p8: (-10?,40?)		p9: (0?,40?)	p10:(10?,40?)
# p11:(-20?,35?)	p12:(-10?,35?)		p13:(0?,35?)	p14:(10?,35?)
#					p15:(-10?,30?)		p16:(0?,30?)
#
# percio' per convertire queste coordinate in pixel del grid dobbiamo sapere come e' fatto il grid, da quanti pixel, con che risoluzione,
# e da dove si parte a contare e in che direzione di contano. Nel caso del database NCEP i pixel sono 144 in orizzontale (long), 73 in vert. (latit)
# la risoluzione e' di 2.5?, e si comincia a contare da 90?N 0?E andando verso est e poi verso sud quando si finisce una fila orizzontale.
# Studiando i valori di pressione ai due poli si capisce che le coordinate di ogni pixel corrispondano al centro del pixel
# in base a queste coordinate, la posizione dei 16 punti all'interno del grid 144x73 del NCEP e' (devi disegnare su un foglio a quadretti il grid):
#
#			 		p1: (141,17)		p2: (1,17)
# p3: (137,19)		p4: (141,19)  		p5: (1,19)		p6: (5,19)
# p7: (137,21)		p8: (141,21)		p9: (1,21)		p10:(5,21)
# p11:(137,23)		p12:(141,23)		p13:(1,23)		p14:(5,23)
#					p15:(141,25)		p16:(1,25)
#
# quindi la posizione dei 16 pixel del database NCEP si puo'riassumere cosi':
# lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1)
# lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25)
# npx.ver=73
# lo stesso ragionamento si puo' applicare al database Emulate, formato da un grid 25 x 10 con risoluzione 5?, e il pixel in alto a sinistra si
# trova a -70?E, 70?N (in questo caso nei metadata ? specificato che le coord.dei pixel Emulate indichino proprio il centroide del pixel):
# la long e lat dei 16 punti di grid per il calcolo dei WTS ? dunque:
#
#			 		p1: (13,5)		p2: (15,5)
# p3: (11,6)		p4: (13,6)  	p5: (15,6)		p6: (17,6)
# p7: (11,7)		p8: (13,7)		p9: (15,7)		p10:(17,7)
# p11:(11,8)		p12:(13,8)		p13:(15,8)		p14:(17,8)
#					p15:(13,9)		p16:(15,9)
#
# quindi la posizione dei 16 pixel del database Emulate si puo' riassumere cosi':
# lon.16p=c(13,15,11,13,15,17,11,13,15,17,11,13,15,17,13,15)
# lat.16p=c(5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9)
# npx.ver=10

NCEP_to_SLP=FALSE # se true, prima di importare il file con i dati di pressione SLP, importa tutti i file del database di pressione NCEP e li
				 # converte nel formato corretto per poterli poi eventualmente convertire in tipi di tempo.
				 # nota che i file con i dati di pressione NCEP hanno tutti una sola colonna con tutti i dati dei grid in verticale, con in piu' una fila con scritto 144*73
				# ogni volta che finisce un grid di 144*73 file, e non ci sono altre colonne che indichino l'anno e/o il mese e/o il giorno e/o la ora.
				
# le opzioni seguenti sono da specificare solo se NCEP_to_SLP=TRUE:
dir_NCEP="C:/nicola/pressure/database_NCEP_Reanalysis/2) database en formado txt"  # directory dove si trovano tutti e solo i file dei dati in formato .txt (un file per ogni mese, con il nome del file lungo 7 cifre e del tipo Anno_Mese)
file_NCEP_standard="C:/nicola/pressure/database_NCEP_Reanalysis/3) database per R/NCEP_formato_standard.txt"  # directory e nome del file dove si mettera il file dei dati standardizzati in formato .txt (un file per ogni mese)
num.grid.for.day=4 # numero di grid di pressione disponibili al giorno (1 se i dati sono giornalieri, 4 se i dati vengono presi ogni 6 ore) [purtroppo per ora bisogna lasciarlo uguale a 4 perche'mi manca una piccola modifica alla riga in cui si calcola la media giornaliera]
NCEP_ori_npx=144 # numero di pixel orizzontali del grid di SLP del NCEP (si assume che si parte da 0 gradi fino a 360 andando verso est)
NCEP_ver_npx=73 # numero di pixel verticali del grid di SLP del NCEP(si assume che si parte da 90 gradi nord fino a -90 gradi andando verso sud)

##### Parametri generici:
int.mesi=c(12,1,2,3,4,5,6,7,8,9,10,11) #c(9,10,11,12,1,2,3,4,5,6,7,8) #c(1) # mesi selezionati per fare la eventuale interpolazione, la regressione e le altre analisi
graph.yx<-c(3,4) # numero di file e colonne di grafici in cui suddividere lo schermo quando si mostrano i grafici mensili selezionati in int.mesi
altro=FALSE # se true, esegue anche analisi secondarie come le mappe per i poster, ecc.
#dir_root="C:/nicola/precipitaciones/weather_types" # cartella dove salvare gli output (.Rdata, mappe, tabelle, ecc.):
#dir_root_kriging="C:/nicola/precipitaciones/kriging_mensuales_Iberia/grids for each year" # cartella dove salvare gli output del kriging:
dir_root="C:/nicola/temperaturas/WTs and temp/output" # cartella dove salvare gli output (.Rdata, mappe, tabelle, ecc.):
dir_root_kriging="C:/nicola/temperturas/WTs and temp/kriging_mensuales_Iberia/grids for each year" # cartella dove salvare gli output del kriging:


##### Parametri interpolazione:
interpol="NO"    # vale "NO" se NON vuoi interpolare prima di fare la regressione dei WTs,
				# vale "SI" per interpolare OGNI ANNO con il metodo scelto sotto e poi si applica il modello di regressione dei WTs sulla serie storica di prec.mensuale di ogni pixel del grid.
				# vale "CLI" per interpolare TUTTO il periodo [start.int-end.int] con il metodo scelto sotto per creare la climatologia
				# (da implementare) vale "ANOM" se prima interpola la climatologia con un il metodo scelto sotto e poi la si moltiplica per le interpolazioni annuali delle anomalie con un Simple Kriging
proyected=TRUE  # vale TRUE se il grid e il DEM sono proiettati, quindi la distanza tra pixel si misura in km, (come nel caso dell'analisi dei WTs)
			        # vale FALSE se il grid e il DEM usano il sistema di coord.geografiche lat long espresse in gradi decimali (come per i modelli di William)
loocv=FALSE	# vale TRUE se invece di interpolare per fare il grid, si interpolano solo le stazioni con la leave-one-out cross-validation (loocv)
start.int=1945 #1971 #1950 #1961 #1948   # Anno iniziale interpolazione (e' lo stesso che si usa anche per il calcolo delle correlazioni tra serie).
end.int=2005 #2000 #2003 #2000 #2003     # Anno finale dell'interpolazione (e per il calcolo delle correlazioni tra serie)
# proprieta' del tipo di grid usato per interpolare:
# per esempio, il grid Mopredas di Michele ha risoluz 0.25 gradi dec, l'angolo in alto a sinistra ha coordinate (-10.125,44.125) e il num.di pixel e' 55(orizz)*34(vert).
# il grid dei modelli Ensemble di Willians ha la stessa risuluzione ed e' definito solo per i pixel di terra in un box piu'piccolo, la intersezione dei due grid ci permette di lavorare su un grid piu'ristretto:
# il grid finale ha risoluzione 0.25 gradi dec, il centro del pixel nell'angolo in alto a sinistra ha coordinate (-9.125,44.125) e il centro del pixel in basso a destra e'(3.125,35.875) (anche se le prime due righe e la ultima sono strisce di mare) ed il numero di pixel e' 50(orizz) * 34(vert).
# Per costruire il grid si usa la funzione GridTopology nella quale bisogna specificare il valore di cellcentre.offset che corrisponde ai valori MINIMI delle coordinate dei PUNTI CENTRALI dei pixel del grid.
# (naturalmente i valori minimi in assoluto si possono ottenere sottraendo ai minimi dei centri la meta' del valore di un pixel, ma R lo calcola gia'in automatico)
coord.system.geograf=CRS("+proj=longlat +datum=WGS84") # sistema di coordinate geografico usato nel caso che proyected sia FALSE
coord.system.proyected=CRS("+proj=utm +zone=30 +datum=WGS84") # sistema di coordinate proiettato usato nel caso proyected sia TRUE
pixel.size.geograf=0.20 #0.25  # lunghezza del lato di un pixel (cioe'risoluzione del grid) in gradi decimali se il sistema di coord.e' quello geografico lat long, es: vale 0.25 gradi decimali se vuoi compararlo con i modelli di William, 
pixel.size.proyected=10   # risoluzione grid proiettato in km	, es: vale 10 km per l'analisi dei WTs.
xmin.box.geograf=-9.6 #-9.125 # valore minimo della longitudine dei pixel del box (rettangolo di lavoro) calcolato pero' nel CENTRO dei pixel
ymin.box.geograf=36 #35.875 # valore minimo della latitudine dei pixel del box (rettangolo di lavoro) calcolato pero' nel CENTRO dei pixel
xmin.box.proyected=-70000
ymin.box.proyected=3980000
num.x.pixels.geograf=70 #50 # equivalente a: (3.125+0.125)-(-9.125-0.125)=12.5 (lunghezza totale riquadro in direz.x in gradi dec.) che diviso per la lunghezza di un pixel di 0.25 da proprio 50
num.y.pixels.geograf=40 #34 # ovvero equivalente a: (xmax - xmin + pixel.size) / pixel.size
num.x.pixels.proyected=ceiling(1110/pixel.size.proyected) # se non sai quanti pixel ci sono in una dimensione, invece di mettere un numero esatto puoi calcolare quanto e' lungo il riquadro e dividere per la lunghezza di un pixel, arrotondando.
num.y.pixels.proyected=ceiling(890/pixel.size.proyected)

# Capas con perimetro Spagna (senza isole) nelle due versioni:
SpainPoly.geograf='C:/Projecto_Master/Limites Espana/borde_espa?a_sin_proyeccion.shp'
SpainPoly.proyected='C:/Projecto_Master/Limites Espana/borde_espa?a_proyected.shp'
# Capa con perimetro Iberian Peninsule e confine tra Spagna e Portogallo: (basta solo la versione in coord.geograf, la versone proiettata la calcola R)
IpPoly.geograf='C:/Projecto_Master/Limites Espana/borde_peniberica_sin_islas_sin_proyeccion.shp'
# Capa con perimetro Iberian Peninsule e confine tra Spagna e Portogallo e Isole Baleari: (basta solo la versione in coord.geograf, la versone proiettata la calcola R)
IpIslesPoly.geograf='C:/Projecto_Master/Limites Espana/borde_peniberica_sin_africa_y_francia_sin_proyeccion.shp'

# Digital Elevation Model: (il nome della variabile dipende dal sistema di coord.scelto, se geografico o proiettato)
mde.geograf="C:/nicola/precipitaciones/Local_Regression_Kriging/aster_gdem_iberian_peninsule_res_0.25.txt"   # nome file e directory del DEM ascii dell'area di lavoro (es: la IP) per fare la regressione locale
mde.proyected="C:/nicola/precipitaciones/correlaciones_para_Martin/datos_decadas/mde_10km_sin_africa.txt" # qui trovi anche un dem a 1 km, se ti serve: "C:/nicola/precipitaciones/correlaciones_para_Martin/datos_decadas/mde_1km_sin_africa.txt" # nome file e directory con l'mde ascii di tipo 1
# IMPORTANTE: il rettangolo di lavoro, la risoluzione e il sistema di coord.geografico del DEM devono essere gli stessi del grid di interpolazione!!!
# usa la funzione Clip management di ArcMAp per ritagliare l'Aster Gdem (24*31 m di risoluzione, non proiettato) e poi la funzione Resample con il metodo bilinear per passare da 0.000277777 gradi di risoluzione a 0.0025 (x9), poi a 0.025 (x90) e infine a 0.25 (x900). Purtroppo non si puo' moltiplicare direttamente per 900, percio' bisogna creare dei raster intermedi.
# il file dev'essere infine convertito in formato ASCII, con ArcMap lo puoi convertire usando la herramienta RasterToASCII; poi pero' devi cambiare le eventuali ',' che indicano l'xllcorner e l'yllcorner e il size in '.' perch? R riconosce solo il punto!
# inoltre se vuoi fare l'interpolazione solo per i punti di terra ti basta mettere NODATA_value uguale al valore dei pixel di mare (es: 0) nel file di testo del MDE. Se devi modificare alcuni pixel del MDE, fallo in excel 2007, perche' ti permette di salvare in txt con sep=" "
# (purtroppo non possiamo ancora lavorare con DEM ad alta risoluzione per poter poi creare in R un DEM a bassa risoluzione a nostro piacimento con la interpolazione bilineare perche'il file ascii convertito misura piu' di 6 GB)
dmax=300 # distanza massima (in km) tra coppie di stazioni per costruire il variogramma (anche quello in gradi decimali, perche'vengono convertiti automaticamente in km dentro la funzione variogram)
# scegli il tipo di interpolazione:
int.method="OK" #"LRK"# OK: Ordinary Kriging; RK: Regression-Kriging ; LRK: Local Regression-Kriging (servono le correlazioni tra serie prima)
int.nmax=50          # numero massimo di vicini usati in qualsiasi tipo di Kriging (solo per velocizzare il calcolo della formula finale con i contributi pesati di ogni stazione, il variogramma lo fa con tutte le stazioni)

##### Parametri della PCA:
PCRA=FALSE # vale TRUE se prima di fare la regressione stepwise si fa la PCA dei WTs usati dalla regressione e li si sostituisce con le EOFs (ricordati di impostare anche negative=TRUE)
stand=TRUE # vale TRUE se prima di fare la PCA si standarizzano i WTs (stranamente produce gli stessi risultati sia che sia TRUE che sia FALSE, come se venisse standardizzato cmq all'interno dell'algoritmo princomp)
correl=FALSE # se true, usa la matrice di correlazione per il calcolo della PCA invece di quella delle covarianze (ma occhio che deve togliere i WTs senza eventi perche'sono predittori costanti)
rotation=FALSE # se true, dopo aver fatto la PCA esegue una varimax rotation dei loadings

##### Parametri della Regressione dei WTs vs Prec.mensile:
n.weather.types=10 # can be 26 or 10. If 10, it converts internally the set of 26 weather types imported in a set of 10 weather types to use in the regression.
start.regr<-1950 #1871 #1948 #1 # anno iniziale periodo calibrazione per fare la regressione stepwise
				 #(di solito coincide con gli anni di prec.mensile disponibili per tutta la penisola iberica).
end.regr<-2010 #2005 #574 # anno finale periodo calibrazione per fare la regressione stepwise
predictand="TEMP"  # can be "PREC" or "TEMP"
intercept=TRUE # vale True se si considera anche l'intercetta (ovvero il termine noto o costante) nella regressione, false altrimenti
negative=TRUE # vale False se i valori dei coefficienti e dell'eventuale intercetta non possono essere mai negativi (usa la funzione lm per fare la regressione, altrimenti usa la funzione nnlm) (il FALSE va usato se si usano i WTs invece delle PCs)
backward=FALSE # vale True se si calcola anche la regressione stepwise con il metodo backward, false solo con il metodo forward
max.autocorrelation=1 #0.4 # exclude all predictor combinations where there are couple of predictors with correlation above this threshold (put 1+ to disactivate it)
min.cv=FALSE # se true, la regressione stepwise minimizza il CV (coefficient of variation = RMSE / media prec.osservata )invece dell'R2 adj. (usato per la precipitaz.)
min.rmse=TRUE # se true, la regressione stepwise minimizza l'RMSE invece dell'R2 adj o del CV (usato di norma ler la temperatura)
step.min.r2=0 # la regressione stepwise si ferma se l'R2 non migliora almeno di step.min.rw (se la regressione non e'stepwise non viene utilizzato)
step.min.CV=0.01 # la regressione stepwise si ferma se il CV (calcolato sullo stesso periodo della regressione) non migliora almeno di step.min.CV  # es: uno step.min.CV di 0.05 equivale a 5 mm di pioggia per una stazione con una media mensile di 100 mm}
step.min.rmse=0.01 # la regressione stepwise si ferma se l'rmse (calcolato sullo stesso periodo della regressione) non migliora almeno di step.min.rmse
stepwise=TRUE # se FALSE, la regressione stepwise non si ferma se l'R2 adj. o il CV o l'rmse non migliorano ma quando ha trovato i primi <num.max.pred> predittori (pur continuando a migliorare l'R2 adj o il CV)
num.max.pred=10 # servono anche se stepwise=TRUE, per definire il numero massimo di predittori che nemmeno il metodo forward/backward puo'oltrepassare (dev'essere inferiore a max.nWT) [serve soprattutto per definire matrici piu'piccole che occupano meno memoria]
jacknife=TRUE # se TRUE, quando ricostruisce la precipitazione e calcola gli indici di errore (CV, COR, MBE, ecc) calcola la prec.prevista per ogni anno del periodo di
# regressione facendo una leave-one-out cross validation, cioe'per ogni anno la prec.ricostruita si calcola sulla base dei coefficienti della regressione calcolata
# solo sugli ALTRI anni della regressione; tuttavia il tipo e il numero dei WTs predittori usati dalla regressione per ricostruire
# la prec.(e l'ordine in cui si introducono) vengono scelti facendo una regressione dove si minimizza sempre l'r2 o il CV ma calcolati NON con il jacknife.
# ovvero si utilizzano i coefficienti calcolati dal modello stepwise senza leave-one-out cross-validation.
jacknife.full=FALSE # se TRUE, il jacknife non si applica solo per ricostruire la precipitazione e calcolare gli indici di errore (cioe' validare il modello)
				     # ma anche per calcolare l'r2 o il CV che servono per selezionare il tipo, l'ordine e il numero di WTs o PCs predittori usati dalla regressione.
only.best=TRUE # se TRUE, durante la validazione del modello non calcola il CV, COR, MBE ecc. anche per le regressioni intermedie dello stepwise, prima di arrivare al migliore insieme di predittori trovato (cosi' va 10 volte piu'veloce a fare il jackknife).
seasons=FALSE # TRUE per fare la regressione a livello stagionale, FALSE a livello mensile. La opzione TRUE (dati stagionali) non e'ancora implementata del tutto

##### Parametri Ricostruzione & Validazione Precipitazioni mensili:
start.recons=1950 #1871 #1 #1948 #1850 #1920 # anno di inizio della ricostruzione (il periodo di ricostruzione puo' includere anche parte o tutto il periodo usato per la calibrazione)
end.recons=2010 #2005 #574 #2003 # ultimo anno riconstruzione (il periodo di ricostruzione puo' includere anche parte o tutto il periodo usato per la calibrazione)
start.valid= 1950 #1945 #1948 #1 #1864 #1956 para los caudales  # anno di inizio del periodo di validazione per il calcolo della bonta'della ricostruzione
# (CV, corr, bias, ecc) occhio che DEVE essere all'interno del periodo indicato per la ricostruzione e NON PUOI impostarlo in periodi ove le serie non hanno nessun dato
# di prec.osservata)
end.valid=2010 #2005 #574 #2003 para los caudales # anno di termine del periodo di validazione per il calcolo della bonta'della ricostruzione (deve essere all'interno del periodo indicato per la ricostruzione)

#nombre y direccion del fichero perl.exe para importar los datos de excel:
perlexe="C:/Toshiba/Strawberry/perl/bin/perl.exe"

#nombre y direccion del fichero python.exe para exportar los datos de excel:
pythonexe="C:/Python27/python.exe"

correl<-FALSE # per calcolare le correlazioni mensili tra tutte le possibili coppie di serie
regr.prec.vs.alt<-FALSE # per fare la regressione della prec vs la altezza

############################# SETTINGS GRAFICI #################################################################################
nome.mese<-c("January","February","March","April","May","June","July","August","September","October","November","December")
nome.mese.esp=c("Enero","Febrero","Marzo","Abril","Mayo","Junio","Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre")
nome.mese.short<-c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec")
n.days.month<-c(31,28.25,31,30,31,30,31,31,30,31,30,31) # mean number of days for month
n.mesi=12

if(seasons==TRUE)then{
	nome.mese<-c("Autumn","Winter","Spring","Summer")
	nome.mese.esp=c("Oto?o","Invierno","Primavera","Verano")
	nome.mese.short<-c("Aut","Win","Spr","Sum")
	n.days.month<-c(91,90.25,92,92) # mean number of days for season
	n.mesi=4
}

month.color=c("orange","darkcyan","red","darkred","darkgreen","magenta4","orange","darkcyan","red","darkred","darkgreen","magenta4") # colori per destinguere i mesi dell'anno
month.color2=c("orange","darkcyan","red","black","darkgreen","magenta4","orange","darkcyan","red","darkred","black","magenta4") # colori per destinguere i mesi dell'anno
col.metodo<-c("orange","darkcyan","blue","red","darkred","darkgreen","green")

jet.colors <-colorRampPalette(c("violet","blue", "#007FFF", "cyan","#7FFF7F", "yellow", "#FF7F00", "red", "#7F0000"))
jet.colors2 <-colorRampPalette(c("violet","blue","cyan","#7FFF7F", "yellow", "#FF7F00", "red"))
jet.colors3 <-colorRampPalette(c("blue","cyan","yellow", "#FF7F00", "red"))
jet.colors4 <-colorRampPalette(c("darkmagenta","blue","yellow","red"))
jet.colors5 <-colorRampPalette(c("blue","cyan","yellow","red"))
jet.colors6 <-colorRampPalette(c("transparent","gold2","red"))
jet.colors7 <-colorRampPalette(c("transparent","gold2","red","black"))
jet.colors8 <-c("red","yellow","cyan","blue")
jet.colors9 <-c("black")
jet.colors10 <-c("red","green2","blue")
jet.colors11<-colorRampPalette(c("mediumorchid4","purple","blue", "#007FFF", "cyan","#7FFF7F", "yellow", "#FF7F00", "red", "#7F0000"))
jet.colors12 <-colorRampPalette(c("violet","blue","cyan","#7FFF7F", "yellow", "#FF7F00")) # same as jet.colors3 per la climatologia del database Ip02
jet.colors13 <-colorRampPalette(c("blue","cyan","white","red","darkred"))
jet.colors14 <-colorRampPalette(c("blue","cyan","gray90","red","darkred"))
jet.colors15 <-colorRampPalette(c("magenta","blue","cyan","gray90","orange","red","darkred"))

jet.colors.pred<-list()

if(PCRA==FALSE){
jet.colors.pred[[1]]<-c("grey78","grey78","grey78","violetred1","red","blue","purple4","cyan","yellow2","aquamarine","gray10","green1","green4","orange","darksalmon","brown4","peachpuff4","gray78","skyblue4","gray78","gray78","gray78","gray78","gray78","seagreen4","red4")
} else {jet.colors.pred[[1]]<-c("violetred1","red","blue","purple4","cyan","yellow2","aquamarine","green1","green4","orange","darksalmon","brown4","peachpuff4","skyblue4","seagreen4","red4","gray78","gray78","gray78","gray78","gray78","gray78","gray78","gray78","gray78","gray78")}
jet.colors.pred[[3]]<-jet.colors.pred[[2]]<-jet.colors.pred[[1]]
jet.colors.pred[[4]]<-jet.colors.pred[[3]] #c("violet","blue","cyan","#7FFF7F","yellow", "orange", "red","brown","black" ,"gray")


WTs.type<-c("NE","E","SE","S","SW","W","NW","N","C","C.NE","C.E","C.SE","C.S","C.SW","C.W","C.NW","C.N","A","A.NE","A.E","A.SE","A.S","A.SW","A.W","A.NW","A.N") 
# tra l'altro questo elenco ha lo stesso ordine dell'elenco dei WTs del database Emulate, che pero' invece di essere enumerati da 1 a 26 assumono questi valori:
# 1,2,3,4,5,6,7,8,30,31.5,32.5,33.5,34.5,35.5,36.5,37.5,38.5,40,41.5,42.5,43.5,44.5,45.5,46.5,47.5,48.5
if(n.weather.types==10)WTs.type<-c("NE","E","SE","S","SW","W","NW","N","C","A") 
WTs.names<-list()

if(PCRA==FALSE){	
	WTs.names[[1]]<-WTs.type # per compatibilita' con le vecchie versioni
	if(n.weather.types==26){	
		WTs.names.long<-c("Northeasterly (NE)","Easterly (E)","Southeasterly (SE)","Southerly (S)","Southwesterly (SW)","Westerly (W)","Northwesterly (NW)",
							"Northerly (N)","Cyclonic (C)","Cyc.Northeasterly (C.NE)","Cyc.Easterly (C.E)","Cyc.Southeasterly (C.SE)","Cyc.Southerly (C.S)",
							"Cyc.Southwesterly (C.SW)","Cyc.Westerly (C.W)","Cyc.Northwesterly (C.NW)","Cyc.Northerly (C.N)","Anticyclonic (A)",
							"Ant.Northeasterly (A.NE)","Ant.Easterly (A.E)","Ant.Southeasterly (A.SE)","Ant.Southerly (A.S)","Ant.Southwesterly (A.SW)",
							"Ant.Westerly (A.W)","Ant.Northwesterly (A.NW)","Ant.Northerly (A.N)")
		WTs.names.long2<-c("Northeasterly","Easterly","Southeasterly","Southerly","Southwesterly","Westerly","Northwesterly",
							"Northerly","Cyclonic","Cyc.Northeasterly","Cyc.Easterly","Cyc.Southeasterly","Cyc.Southerly",
							"Cyc.Southwesterly","Cyc.Westerly","Cyc.Northwesterly","Cyc.Northerly","Anticyclonic",
							"Ant.Northeasterly","Ant.Easterly","Ant.Southeasterly","Ant.Southerly","Ant.Southwesterly",
							"Ant.Westerly","Ant.Northwesterly","Ant.Northerly")
	} else { # in this case we are working with 10 weather types only
		WTs.names.long<-c("Northeasterly (NE)","Easterly (E)","Southeasterly (SE)","Southerly (S)","Southwesterly (SW)","Westerly (W)","Northwesterly (NW)",
							"Northerly (N)","Cyclonic (C)","Anticyclonic (A)")
		WTs.names.long2<-c("Northeasterly","Easterly","Southeasterly","Southerly","Southwesterly","Westerly","Northwesterly",
							"Northerly","Cyclonic","Anticyclonic")
	}
	WTs.names.full<-c(WTs.names[[1]],"I")
	WTs.names[[3]]<-WTs.names[[2]]<-WTs.names[[1]]
	WTs.names[[4]]<-WTs.names[[3]] #c("A","AE","AS","AW","AN","C","CE","CS","CW","CN")

	WTs.short.names1<-c("NW","N","NE","W","C","E","SW","S","SE")
	WTs.short.names2<-c("C.NW","C.N","C.NE","C.W","C","C.E","C.SW","C.S","C.SE")
	WTs.short.names3<-c("A.NW","A.N","A.NE","A.W","A","A.E","A.SW","A.S","A.SE")
	WTs.short.names4<-c("NW","N","NE","W","I","E","SW","S","SE")

	WTs.full.names1<-c("Northwesterly","Northerly","Northeasterly","Westerly","Cyclonic","Easterly","Southwesterly","Southerly","Southeasterly")
	WTs.full.names2<-c("Cyc.Northwesterly","Cyc.Northerly","Cyc.Northeasterly","Cyc.Westerly","Pure Cyclonic","Cyc.Easterly","Cyc.Southwesterly","Cyc.Southerly","Cyc.Southeasterly")
	WTs.full.names3<-c("Antic.Northwesterly","Antic.Northerly","Antic.Northeasterly","Antic.Westerly","Pure Anticyclonic","Antic.Easterly","Antic.Southwesterly","Antic.Southerly","Antic.Southeasterly")
	WTs.full.names4<-c("Northwesterly","Northerly","Northeasterly","Westerly","Constant term","Easterly","Southwesterly","Southerly","Southeasterly")

} else {WTs.names[[1]]<-paste("PC",1:26,sep="")}

class.color=c("blue","red") # colori per distinguere la 20th Century Project classification dalla EMULATE
############################ FUNZIONI #############################################################################################################

endmonth<-function(day,month,year){ # day indica un giorno del mese di cui si vuole controllare se e' l'ultimo giorno del mese o meno:
	last=FALSE
	if(month==1 & day==31)last=TRUE;if(month==3 & day==31)last=TRUE;if(month==4 & day==30)last=TRUE;if(month==5 & day==31)last=TRUE
	if(month==6 & day==30)last=TRUE;if(month==7 & day==31)last=TRUE;if(month==8 & day==31)last=TRUE;if(month==9 & day==30)last=TRUE
	if(month==10 & day==31)last=TRUE;if(month==11 & day==30)last=TRUE;if(month==12 & day==31)last=TRUE
	if(year%%400==0 | (year%%4==0 & year%%100!=0)){ # in questo caso l'anno e' bisestile)
	 if(month==2 & day==29)last=TRUE } else { # Anno NON bisestile:
	 if(month==2 & day==28)last=TRUE }
	return(last)
}
lastday<-function(month,year){ # simile alla precedente, restituisce qual'e'l'ultimo giorno del mese introdotto
	if(month==1 | month==3 | month==5 | month==7 | month==8 | month==10 | month==12)last=31
	if(month==4 | month==6 | month==9 | month==11)last=30
	if(month==2){
	if(year%%400==0 | (year%%4==0 & year%%100!=0)){last==29} else {last=28}
	}
	if(year==1 & month==2)last=28.25 # se si mette come anno il numero 1, restituisce il numero medio di giorni di febbraio quando si considerano tanti anni (28.25). Utile per calcolare le frequenze dei WTs del mese di febbraio.
	return(last)
}

RMSE<-function(obs,pred){ # semplice funzione per calcolare l'errore quadratico medio dato il vettore con la grandezza osservata e quello con la previsione (possono esserci anche NA nel vettore obs)
	# i pred hanno sempre tutti i valori predetti annuali, mentre potrebbero esserci anni senza valori osservati, dunque devo togliere solo le file corrispondenti agli anni con NA tra i valori obs:
	years.right<-which(is.na(obs)==FALSE)
	obs2<-obs[years.right]
	pred2<-pred[years.right]
	sum.scarti.quad<-sum((obs2-pred2)^2,na.rm=TRUE)
	RMSE<-(sum.scarti.quad/(length(years.right)))^0.5 # devi togliere dal denominatore gli anni con NA!!! 
	return(RMSE)
}

MAE<-function(obs,pred){ # semplice funzione per calcolare il mean Absolute Error dato il vettore con la grandezza osservata e quello con la previsione (possono esserci anche NA nel vettore obs)
	# i pred hanno sempre tutti i valori predetti annuali, mentre potrebbero esserci anni senza valori osservati, dunque devo togliere solo le file corrispondenti agli anni con NA tra i valori obs:
	years.right<-which(is.na(obs)==FALSE)
	obs2<-obs[years.right]
	pred2<-pred[years.right]
	MAE<-sum(abs(obs2-pred2))/(length(years.right)) # devi togliere dal denominatore gli anni con NA!!! 
	return(MAE)
}

MAEp<-function(obs,pred){ # semplice funzione per calcolare il Mean Absolute Error in percentuale (%) dato il vettore con la grandezza osservata e quello con la previsione (possono esserci anche NA nel vettore obs)
	# i pred hanno sempre tutti i valori predetti annuali, mentre potrebbero esserci anni senza valori osservati, dunque devo togliere solo le file corrispondenti agli anni con NA tra i valori obs:
	years.right<-which(is.na(obs)==FALSE)
	obs2<-obs[years.right]
	pred2<-pred[years.right]
	MAE<-sum(abs(obs2-pred2))/(length(years.right)) # devi togliere dal denominatore gli anni con NA!!! 
	obs.prom<-sum(obs2)/length(years.right)
	MAE<-MAE/obs.prom
	return(MAE)
}

MBE<-function(obs,pred){ # semplice funzione per calcolare l'errore medio (Mean Bias Error) (ci possono essere anche elementi con NA nel vettore obs)
	# i pred hanno sempre tutti i valori predetti annuali, mentre potrebbero esserci anni senza valori osservati, dunque devo togliere le file corrispondenti agli anni con NA tra i valori obs:
	years.right<-which(is.na(obs)==FALSE)
	obs2<-obs[years.right]
	pred2<-pred[years.right]
	MBE<-sum(pred2-obs2)/(length(years.right))
	return(MBE)
}

AGREE<-function(obs,pred){ # per calcolare la d di Willmott o Index of agreement OCCHIO che e' insensibile a sovra/sottostime quasi come l'R2
	years.right<-which(is.na(obs)==FALSE)
	obs2<-obs[years.right]
	pred2<-pred[years.right]
	sum.scarti.quad<-sum((obs2-pred2)^2,na.rm=TRUE)
	obs2.mean<-mean(obs2)
	d<-1-(sum.scarti.quad/(sum((abs(pred2-obs2.mean)+abs(obs2-obs2.mean))^2)))
	return(d)
}

AGREE.1<-function(obs,pred){ # d di Willmott corretto senza i quadrati
	years.right<-which(is.na(obs)==FALSE)
	obs2<-obs[years.right]
	pred2<-pred[years.right]
	sum.scarti<-sum(abs(obs2-pred2),na.rm=TRUE)
	obs2.mean<-mean(obs2)
	d1<-1-(sum.scarti/(sum(abs(pred2-obs2.mean)+abs(obs2-obs2.mean))))
	return(d1)
}

AGREE.2011<-function(obs,pred){ # nuova d di Willmott introdotta da lui nel 2011 
	years.right<-which(is.na(obs)==FALSE)
	obs2<-obs[years.right]
	pred2<-pred[years.right]
	sum.scarti<-sum(abs(obs2-pred2),na.rm=TRUE)
	obs2.mean<-mean(obs2)
	denom<-2*sum(abs(obs2-obs2.mean)) # denominatore della formula di d(r)
	if(sum.scarti<=denom){d.2011<-1-(sum.scarti/denom)}else{d.2011<-(denom/sum.scarti)-1}
	return(d.2011)
}

RMSE.freedom<-function(obs,pred,degree.freedom){ # funzione per calcolare l'errore quadratico medio dato il vettore con la grandezza osservata e quello con la previsione (possono esserci anche NA nel vettore obs)
	# i pred hanno sempre tutti i valori predetti annuali, mentre potrebbero esserci anni senza valori osservati, dunque devo togliere le file corrispondenti agli anni con NA tra i valori obs:
	years.right<-which(is.na(obs)==FALSE)
	obs2<-obs[years.right]
	pred2<-pred[years.right]
	sum.scarti.quad<-sum((obs2-pred2)^2,na.rm=TRUE)
	RMSE<-(sum.scarti.quad/degree.freedom)^0.5
	return(RMSE)
}

SumSquared<-function(obs,pred){ # semplice funzione per calcolare la somma dei quadrati degli scarti dato il vettore con la grandezza osservata e quello con la previsione (possono esserci anche NA nel vettore obs)
	# i pred hanno sempre tutti i valori predetti annuali, mentre potrebbero esserci anni senza valori osservati, dunque devo togliere le file corrispondenti agli anni con NA tra i valori obs:
	years.right<-which(is.na(obs)==FALSE)
	obs2<-obs[years.right]
	pred2<-pred[years.right]
	sum.scarti.quad<-sum((obs2-pred2)^2,na.rm=TRUE)
	return(sum.scarti.quad)
}


# Funzione per fare la regressione (inclusa perche'piu' veloce di lm(), sarebbe una versione modificata di lm.fit() senza troppi output  )
# dalla versione 2.15 di R non la puoi piu?usare, usa invece lm.fit.fast2
# occhio che con lm.fit bisogna passare anche una colonna di uno iniziali per simulare il termine noto!!!
lm.fit.fast<-function (x, y, offset = NULL, method = "qr", tol = 1e-07, singular.ok = TRUE, ...) 
{
    if (is.null(n <- nrow(x))) 
        stop("'x' must be a matrix")
    if (n == 0L) 
        stop("0 (non-NA) cases")
    p <- ncol(x)
    if (p == 0L) {
        return(list(coefficients = numeric(0L), residuals = y, 
            fitted.values = 0 * y, rank = 0, df.residual = length(y)))
    }
    ny <- NCOL(y)
    if (is.matrix(y) && ny == 1) 
        y <- drop(y)
    if (!is.null(offset)) 
        y <- y - offset
    if (NROW(y) != n) 
        stop("incompatible dimensions")
    if (method != "qr") 
        warning(gettextf("method = '%s' is not supported. Using 'qr'", 
            method), domain = NA)
    if (length(list(...))) 
        warning("extra arguments ", paste(names(list(...)), sep = ", "), 
            " are just disregarded.")
    storage.mode(x) <- "double"
    storage.mode(y) <- "double"
    z <- .Fortran("dqrls", qr = x, n = n, p = p, y = y, ny = ny, 
        tol = as.double(tol), coefficients = mat.or.vec(p, ny), 
        residuals = y, effects = y, rank = integer(1L), pivot = 1L:p, 
        qraux = double(p), work = double(2 * p), PACKAGE = "base")
    if (!singular.ok && z$rank < p) 
        stop("singular fit encountered")
    coef <- z$coefficients
    pivot <- z$pivot
    r1 <- seq_len(z$rank)
    dn <- colnames(x)
    if (is.null(dn)) 
        dn <- paste("x", 1L:p, sep = "")
    r2 <- if (z$rank < p) 
        (z$rank + 1L):p
    else integer(0L)
    if (is.matrix(y)) {
        coef[r2, ] <- NA
        coef[pivot, ] <- coef
        dimnames(coef) <- list(dn, colnames(y))
    }
    else {
        coef[r2] <- NA
        coef[pivot] <- coef
        names(coef) <- dn
    }
    z$coefficients <- coef
    r1 <- y - z$residuals
    if (!is.null(offset)) 
        r1 <- r1 + offset
   c(z[c("coefficients", "residuals", "rank")], list(fitted.values = r1, df.residual = n - z$rank))
}

# Dopo la versione 2.15 di R le funzioni .Fortran() sono proibite, bisogna sostituirle con .Call,
# percio' invece di lm.fit.fast bisogna chiamare lm.fit.fast2:
lm.fit.fast2<-function (x, y, offset = NULL, method = "qr", tol = 1e-07, singular.ok = TRUE, ...) 
{
    if (is.null(n <- nrow(x))) 
        stop("'x' must be a matrix")
    if (n == 0L) 
        stop("0 (non-NA) cases")
    p <- ncol(x)
    if (p == 0L) {
        return(list(coefficients = numeric(0L), residuals = y, 
            fitted.values = 0 * y, rank = 0, df.residual = length(y)))
    }
    ny <- NCOL(y)
    if (is.matrix(y) && ny == 1) 
        y <- drop(y)
    if (!is.null(offset)) 
        y <- y - offset
    if (NROW(y) != n) 
        stop("incompatible dimensions")
    if (method != "qr") 
        warning(gettextf("method = '%s' is not supported. Using 'qr'", 
            method), domain = NA)
    if (length(list(...))) 
        warning("extra arguments ", paste(names(list(...)), sep = ", "), 
            " are just disregarded.")
    storage.mode(x) <- "double"
    storage.mode(y) <- "double"
	
	z <- .Call(stats:::C_Cdqrls, x, y, tol, TRUE)
	
    if (!singular.ok && z$rank < p) 
        stop("singular fit encountered")
    coef <- z$coefficients
    pivot <- z$pivot
    r1 <- seq_len(z$rank)
    dn <- colnames(x)
    if (is.null(dn)) 
        dn <- paste("x", 1L:p, sep = "")
    r2 <- if (z$rank < p) 
        (z$rank + 1L):p
    else integer(0L)
    if (is.matrix(y)) {
        coef[r2, ] <- NA
        coef[pivot, ] <- coef
        dimnames(coef) <- list(dn, colnames(y))
    }
    else {
        coef[r2] <- NA
        coef[pivot] <- coef
        names(coef) <- dn
    }
    z$coefficients <- coef
    r1 <- y - z$residuals
    if (!is.null(offset)) 
        r1 <- r1 + offset
   c(z[c("coefficients", "residuals", "rank")], list(fitted.values = r1, df.residual = n - z$rank))
}

north.arrow <- function(loc,size,bearing=0,cols,cex=1,...) {
	# checking arguments
	if(missing(loc)) stop("loc is missing")
	if(missing(size)) stop("size is missing")
	# default colors are white and black
	if(missing(cols)) cols <- rep(c("white","black"),8)
	# calculating coordinates of polygons
	radii <- rep(size/c(1,4,2,4),4)
	x <- radii[(0:15)+1]*cos((0:15)*pi/8+bearing)+loc[1]
	y <- radii[(0:15)+1]*sin((0:15)*pi/8+bearing)+loc[2]
	# drawing polygons
	for (i in 1:15) {
	x1 <- c(x[i],x[i+1],loc[1])
	y1 <- c(y[i],y[i+1],loc[2])
	polygon(x1,y1,col=cols[i])
	}
	# drawing the last polygon
	polygon(c(x[16],x[1],loc[1]),c(y[16],y[1],loc[2]),col=cols[16])
	# drawing letters
	b <- c("E","N","W","S")
	for (i in 0:3) text((size+par("cxy")[1])*cos(bearing+i*pi/2)+loc[1],
	(size+par("cxy")[2])*sin(bearing+i*pi/2)+loc[2],b[i+1],
	cex=cex)
}

n.days.in.a.year<-function(year)return(ifelse((year%%4==0 & year%%100!=0) | year%%400==0,366,365))

seq.months.in.a.year<-function(year){ # restituisce una sequenza di 365 o 366 numeri, il cui valore rappres.il numero del mese dell'anno associato a quel giorno
	n.days.febr<-ifelse(n.days.in.a.year(year)==366,29,28)
	return(c(rep(1,31),rep(2,n.days.febr),rep(3,31),rep(4,30),rep(5,31),rep(6,30),rep(7,31),rep(8,31),rep(9,30),rep(10,31),rep(11,30),rep(12,31)))
}

rescale.max<-function(my.array,val.max){ # funzione che prende un array e restituisce lo stesso array abbassando pero'tutti gli elementi piu'alti di val.max al valore val.max (utile per aggiustare le leggende dei grafici)
	ss<-which(my.array>val.max)
	my.array[ss]<-val.max 
	return(my.array)
}
rescale.min<-function(my.array,val.min){ # come rescale.max ma per i valori piu'piccoli di val.min che vengono cambiati a val.min
	ss<-which(my.array<val.min)
	my.array[ss]<-val.min
	return(my.array)
}
rescale<-function(my.array,val.min,val.max){ # unisce rescale.max con rescale.min
	ss<-which(my.array>val.max)
	my.array[ss]<-val.max 
	ss<-which(my.array<val.min)
	my.array[ss]<-val.min
	return(my.array)
}

myboxplot.stats <-  function (x, coef = NULL, do.conf = TRUE, do.out =
TRUE)
{
  nna <- !is.na(x)
  n <- sum(nna)
  stats <- quantile(x, c(.05,.25,.5,.75,.95), na.rm = TRUE)
  iqr <- diff(stats[c(2, 4)])
  out <- x < stats[1] | x > stats[5]
  conf <- if (do.conf)
    stats[3] + c(-1.58, 1.58) * diff(stats[c(2, 4)])/sqrt(n)
  list(stats = stats, n = n, conf = conf, out = x[out & nna])
} 

########################### Conversione dei dati di pressione NCEP a dati di pressione in formato standard (se lo si e' impostato) #########################################3
# ogni volta che aggiungi nuovi mesi nella directory"C:\nicola\pressure\database_NCEP_Reanalysis\2) database en formado txt"
# ti basta far correre questo script per creare il nuovo file in "C:/nicola/pressure/database_NCEP_Reanalysis/3) database per R/NCEP_formato_standard.txt" 
if(NCEP_to_SLP==TRUE){ 
	setwd(dir_NCEP)
	filemesi<-list.files()
	n.filemesi=length(filemesi) # numero di file su cui si calcola la SLP
	nome.filemesi<-substr(filemesi,1,nchar(filemesi)-4) #toglie il .txt alla fine del nome ogni file
	anno.filemesi<-as.numeric(substr(nome.filemesi,1,4)) # estrae l'anno dal nome del file
	mese.filemesi<-as.numeric(substr(nome.filemesi,6,7)) # estrae l'anno dal nome del file (e' possibile perche' i mesi vengono sempre identificati da 2 numeri alla fine del nome del file)
	standard.SLP.full<-c()
	i=1 # conta il file a cui siamo arrivati a esaminare
	barraP<-winProgressBar("Analyzing data","Please wait...",0,n.filemesi,0)
	for(x in filemesi){
		 listaNCEP<- read.table(x,stringsAsFactors=FALSE,fill=T) # legge ogni mese di dati di SLP
		 ss<-which(!is.na(listaNCEP[,2]))# rimuove tutte le colonne oltre la prima (se ci sono), e anche tutte le file con dati su ambo le colonne (sono quelle che non corrispondono a dati veri ma al numero di pixel del grid, che si ripete ogni volta che si cambia grid)
		 listaNCEP<-listaNCEP[-ss,]
		 listaNCEP<-listaNCEP[,1] # rimuove tutte le colonne oltre la prima; il data.frame diventa un vettore
		 listaNCEP<-cbind(anno.filemesi[i],mese.filemesi[i],listaNCEP) # aggiunge due colonne a sx con l'anno e il mese dei dati
		 
		 # se i dati di SLP sono presi ogni X ore, li converte a giornalieri:
		 n.gg_al_mese<-dim(listaNCEP)[1]/(NCEP_ori_npx*NCEP_ver_npx*num.grid.for.day) # conta il numero di giorni per il mese importato 
		 
		 n.pixel<-NCEP_ori_npx*NCEP_ver_npx # conta il numero di pixel per ogni grid
		 n.rows.for.day<-num.grid.for.day*n.pixel# conta il numero di file di dati per ogni giorno del mese (coincide con dim(listaNCEP[[i]])[1]/n.gg_al_mese
		 
		 media<-c() # vettore che contiene le medie giornaliere dei grid di pressione tutte su una sola colonna

		 #fa la media di ogni <num.grid.for.day> griglie per calcolare la griglia giornaliera:
		 for(day in  1:n.gg_al_mese){
			 # seleziona i <num.grid.for.day> grid corrispondenti allo stesso giorno e li mette nel vettore media: (finora funziona solo per <num.grid.for.day>=4 perche' la somma e' fissata su 4 termini e non si puo' cambiare senza fare un ciclo for)
			media[(n.pixel*(day-1)+1):(n.pixel*day)]<-(listaNCEP[(n.rows.for.day*(day-1)+n.pixel*0+1):(n.rows.for.day*(day-1)+n.pixel*1),3]+
														listaNCEP[(n.rows.for.day*(day-1)+n.pixel+1):(n.rows.for.day*(day-1)+n.pixel*2),3]+
														listaNCEP[(n.rows.for.day*(day-1)+n.pixel*2+1):(n.rows.for.day*(day-1)+n.pixel*3),3]+
														listaNCEP[(n.rows.for.day*(day-1)+n.pixel*3+1):(n.rows.for.day*(day-1)+n.pixel*4),3])/num.grid.for.day
														
		 } # chiude il for su day per fare la media dei giornalieri
		 
		# converte il vettore con la media da verticale a orizzontale per adottarlo al formato standard della SLP:
		standard.SLP<-c() #array(NA,c(n.pixel,NCEP_ori_npx))
		for(day in 1:n.gg_al_mese){
			tabla.temp<-media[(n.pixel*(day-1)+1):(n.pixel*day)]
			tabla.temp<-matrix(tabla.temp,nrow=NCEP_ver_npx,ncol=NCEP_ori_npx,byrow=T)
			tabla.temp<-cbind(anno.filemesi[i],mese.filemesi[i],day,tabla.temp)
			if(day>1){standard.SLP<-rbind(standard.SLP,tabla.temp)} else {standard.SLP<-tabla.temp}
		}
		 
		 if(i==1){standard.SLP.full<-standard.SLP} else {standard.SLP.full<-rbind(standard.SLP.full,standard.SLP)}
		 i<-i+1 # passa al prossimo file
		 setWinProgressBar(barraP,i,label=paste(i,"/",n.filemesi) )
	 };close(barraP) # for su x (passa al prossimo file)
	
	write.table(standard.SLP.full,file_NCEP_standard,quote=FALSE,row.names=FALSE,col.names=FALSE)
	
} # chiude l'if su SLP_to_WTs

########################### Classificazione dei dati di pressione in Weather Types (se lo si e' impostato) #########################################3

if(SLP_to_WTs==TRUE){ # in questo caso crea prima la classificazione di tipi di tempo giornalieri a partire dai campi di pressione di input:
	standard.SLP.full<-read.table(file.SLP,stringsAsFactors=FALSE,header=FALSE,fill=TRUE) # legge tutti i dati giornalieri di SLP	
	n.days.SLP<-dim(standard.SLP.full)[1]/npx.ver # numero di giorni di tuuuuutto il periodo di dati di SLP
	WTs.type<-c("NE","E","SE","S","SW","W","NW","N","C","C.NE","C.E","C.SE","C.S","C.SW","C.W","C.NW","C.N","A","A.NE","A.E","A.SE","A.S","A.SW","A.W","A.NW","A.N") 

	# se abbiamo importato il database EMULATE nella versione non normalizzata al formato anno/mese/giorno/grid che si scarica da internet, dobbiamo ricreare le colonne con anno/mese/giorno:
	# NON farlo con Excel perche' importa i dati cambiando l'ordine!!!!!
	# sequ<-1+seq(0,dim(standard.SLP.full)[1]-1,npx.ver+1)
	# C1<-standard.SLP.full[sequ,1]
	# C2<-standard.SLP.full[sequ,2]
	# C3<-standard.SLP.full[sequ,3]
	# standard.SLP.full2<-standard.SLP.full[-sequ,]
	# C4<-rep(C1,each=npx.ver)
	# C5<-rep(C2,each=npx.ver)
	# C6<-rep(C3,each=npx.ver)
	# C.all<-cbind(C4,C5,C6)
	# standard.SLP.full2<-cbind(C.all,standard.SLP.full2)
	# write.table(standard.SLP.full2,file="C:/nicola/pressure/database_emulate/2) emulate_normalizado_1850-2003.txt"  ,row.names=FALSE,col.names=FALSE,quote=FALSE)

	for(point in 1:12){ # this for is needed only for the 12 points over Spain used by Estela
		if(point==1){point.name<-"point_#1_coord_-7?30'E_42?30'N.txt";lon.16p=c(141,145,137,141,145,5,137,141,145,5,137,141,145,5,141,145)-1;lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25)-1;lat.central=42.5;lat.2nd.row=lat.central+5}
		if(point==2){point.name<-"point_#2_coord_-5?E_42?30'N.txt";lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1);lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25)-1;lat.central=42.5;lat.2nd.row=lat.central+5}
		if(point==3){point.name<-"point_#3_coord_-2?30'E_42?30'N.txt";lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1)+1;lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25)-1;lat.central=42.5;lat.2nd.row=lat.central+5}
		if(point==4){point.name<-"point_#4_coord_0?E_42?30'N.txt";lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1)+2;lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25)-1;lat.central=42.5;lat.2nd.row=lat.central+5}
		if(point==5){point.name<-"point_#5_coord_2?30'E_42?30'N.txt";lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1)+3;lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25)-1;lat.central=42.5;lat.2nd.row=lat.central+5} 
		if(point==6){point.name<-"point_#6_coord_-7?30'E_40?N.txt";lon.16p=c(141,145,137,141,145,5,137,141,145,5,137,141,145,5,141,145)-1;lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25);lat.central=40;lat.2nd.row=lat.central+5}
		if(point==7){point.name<-"point_#7_coord_-5?E_40?N.txt";lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1);lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25);lat.central=40;lat.2nd.row=lat.central+5}
		if(point==8){point.name<-"point_#8_coord_-2?30'E_40?N.txt";lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1)+1;lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25);lat.central=40;lat.2nd.row=lat.central+5}
		if(point==9){point.name<-"point_#9_coord_0?E_40?N.txt";lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1)+2;lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25);lat.central=40;lat.2nd.row=lat.central+5}
		if(point==10){point.name<-"point_#10_coord_-7?30'E_37?30'N.txt";lon.16p=c(141,145,137,141,145,5,137,141,145,5,137,141,145,5,141,145)-1;lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25)+1;lat.central=37.5;lat.2nd.row=lat.central+5}
		if(point==11){point.name<-"point_#11_coord_-5?E_37?30'N.txt";lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1);lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25)+1;lat.central=37.5;lat.2nd.row=lat.central+5}
		if(point==12){point.name<-"point_#12_coord_-2?30'E_37?30'N.txt";lon.16p=c(141,1,137,141,1,5,137,141,1,5,137,141,1,5,141,1)+1;lat.16p=c(17,17,19,19,19,19,21,21,21,21,23,23,23,23,25,25)+1;lat.central=37.5;lat.2nd.row=lat.central+5}
		
		# estrae solo le serie diarie di pressione corrispondenti ai 16 pixel scelti dall'utente e li mette nelle 16 colonne di SLP16:
		for(i in 1:16){ # cicla sui 16 punti
			# seleziona i dati di anno/mese/giorno per ogni giorno di dati:
			seq.days<-lat.16p[i]+seq(0,npx.ver*(n.days.SLP-1),npx.ver)
			#standard.SLP.full[lat.16p[i]+npx.ver*0,c(1:3,3+lon.16p[i])] 
			#standard.SLP.full[lat.16p[i]+npx.ver*1,c(1:3,3+lon.16p[i])] 
			if(i==1){SLP16<-standard.SLP.full[seq.days,c(1:3,3+lon.16p[i])]} else {SLP16<-cbind(SLP16,standard.SLP.full[seq.days,3+lon.16p[i]])}
		}
		names(SLP16)<-c("Year","Month","Day","P1","P2","P3","P4","P5","P6","P7","P8","P9","P10","P11","P12","P13","P14","P15","P16")
		
		#lat.2nd.row=lat.central+5 # already defined in the header
		lat.4rd.row=lat.central-5
		
		# calcola i coefficienti degli indici geostrofici (occhio a non arrotondarli alla terza cifra decimale come fanno Ricardo o Martin-Vide perche cosi si introduce un errore che cambia i WT nel 3-4% dei casi!!!:
		SF1<-1/cos(lat.central*pi/180) 
		ZS1<-1/(2*cos(lat.central*pi/180)^2)
		ZW1<-sin(lat.central*pi/180)/sin(lat.4rd.row*pi/180)
		ZW2<-sin(lat.central*pi/180)/sin(lat.2nd.row*pi/180)
		
		# calcola gli indici geostrofici:
		SF<-WF<-F<-D<-D2<-D3<-c()
		SF=SF1*(0.25*(SLP16[,"P5"]+2*SLP16[,"P9"]+SLP16[,"P13"])-0.25*(SLP16[,"P4"]+2*SLP16[,"P8"]+SLP16[,"P12"]))
		WF=0.5*(SLP16[,"P12"]+SLP16[,"P13"])-0.5*(SLP16[,"P4"]+SLP16[,"P5"])
		F=(SF*SF+WF*WF)^0.5
		D=(180/pi)*atan(WF/SF) # D e' la direzione del flusso; dato che l'angolo risultato di atan e' espresso in radianti, bisogna convertirlo in gradi moltiplicandolo per (180/pi)

		#SF2<-WF2<-F2<-D2<-D22<-D32<-c()
		#SF2=SF1*(0.25*(SLP16[,"P5"]+2*SLP16[,"P9"]+SLP16[,"P13"])-0.25*(SLP16[,"P4"]+2*SLP16[,"P8"]+SLP16[,"P12"]))
		#WF2=0.5*(SLP16[,"P12"]+SLP16[,"P13"])-0.5*(SLP16[,"P4"]+SLP16[,"P5"])
		#F2=(SF*SF+WF*WF)^0.5
		#D2=(180/pi)*atan(WF/SF) # D e' la direzione del flusso; dato che l'angolo risultato di atan e' espresso in radianti, bisogna convertirlo in gradi moltiplicandolo per (180/pi)
		
		# trasforma l'angolo D iniziale in un angolo D2 sempre positivo che si calcola a partire del Nord andando in senso orario:
		# trasformazione di Sergio Vicente Serrano:
		quad1<-which(WF<0 & SF<=0)	# calcola quali angoli D appartengono al quadrante 1, quali al quadrante 2, quali al 3 e quali al 4.
		quad2<-which(WF<0 & SF>0)	# il primo quadrante e' in alto a destra, il secondo in basso a destra, il terzo in basso a sinistra, il quarto in alto a sinistra.
		quad3<-which(WF>0 & SF>0)
		quad4<-which(WF>0 & SF<=0)
		
		D2<-D
		D2[quad2]<-D[quad2]+180
		D2[quad3]<-D[quad3]+180
		D2[quad4]<-D[quad4]+360
			
		# individua i WTs direzionali:
		NE<-which(D2>=22.5 & D2<67.5)
		E<-which(D2>=67.5 & D2<112.5)
		SE<-which(D2>=112.5 & D2<157.5)
		S<-which(D2>=157.5 & D2<202.5)
		SW<-which(D2>=202.5 & D2<247.5)
		W<-which(D2>=247.5 & D2<292.5)
		NW<-which(D2>=292.5 & D2<337.5)
		N<-which(D2>=337.5 | D2<22.5)
		
		# aggiunge una colonna a destra con il WT direzionale associato all'angolo:
		D2.dir<-rep("-999",length(D2))
		D2.dir[NE]<-"NE";D2.dir[E]<-"E";D2.dir[SE]<-"SE";D2.dir[S]<-"S";D2.dir[SW]<-"SW";D2.dir[W]<-"W";D2.dir[NW]<-"NW";D2.dir[N]<-"N"
		
		D3<-as.data.frame(cbind(SLP16[,1:3],D2,D2.dir),stringsAsFactors=FALSE) # aggiunge la colonna a destra di D2
		D3$Year<-as.numeric(D3$Year);D3$Month<-as.numeric(D3$Month);D3$Day<-as.numeric(D3$Day);D3$D2<-as.numeric(D3$D2);D3$D2.dir<-as.character(D3$D2.dir)
		
		# calcolo componenti vorticita':
		ZS<-ZW<-Z<-c()
		ZS=ZS1*(0.25*(SLP16[,"P6"]+2*SLP16[,"P10"]+SLP16[,"P14"])-0.25*(SLP16[,"P5"]+2*SLP16[,"P9"]+SLP16[,"P13"])-0.25*(SLP16[,"P4"]+2*SLP16[,"P8"]+SLP16[,"P12"])+0.25*(SLP16[,"P3"]+2*SLP16[,"P7"]+SLP16[,"P11"]))
		ZW=ZW1*(0.5*(SLP16[,"P15"]+SLP16[,"P16"])-0.5*(SLP16[,"P8"]+SLP16[,"P9"]))-ZW2*(0.5*(SLP16[,"P8"]+SLP16[,"P9"])-0.5*(SLP16[,"P1"]+SLP16[,"P2"]))
		Z=ZS+ZW

		cyc.pure<-which(Z>2*F)
		anticyc.pure<-which(Z<(-2*F))
		hybrid.cyc<-which(abs(Z)<2*F & abs(Z)>F & Z>0)
		hybrid.anticyc<-which(abs(Z)<2*F & abs(Z)>F & Z<0)
		indeter<-which(F<6 | abs(Z)<6) # tipo di tempo indeterminato (U)
		
		# colonna che identifica quali giorni sono di tipo ibrido e quali di tipo direzionale:
		D3$Hyb<-rep("Directional",length(D2))
		D3$Hyb[cyc.pure]<-"Pure C"
		D3$Hyb[anticyc.pure]<-"Pure A"
		D3$Hyb[hybrid.cyc]<-"Hybrid C"
		D3$Hyb[hybrid.anticyc]<-"Hybrid A"
		
		# colonna con la lista dei 26 WTs officiali:
		D3$WT<-D3$D2.dir
		D3$WT[cyc.pure]<-"C"
		D3$WT[anticyc.pure]<-"A"
		D3$WT[hybrid.cyc]<-paste("C.",D3$D2.dir[hybrid.cyc],sep="")
		D3$WT[hybrid.anticyc]<-paste("A.",D3$D2.dir[hybrid.anticyc],sep="")
		#D3$WT[indeter]<-"U"
		
		D3$WT.num<-match(D3$WT,WTs.type)# aggiunge una colonna con la conversione dei 26 tipi di tempo a numeri da 1 a 26
		
		# colonna con la lista dei 10 WTs ottenuti unendo a C e ad A gli otto direzionali; gli altri WTs ibridi si aggiungono ognuno al suo tipo direzionale corrispondente (es: C.SW si aggiunge a SW, ecc.)
		D3$WT10<-D3$D2.dir
		D3$WT10[cyc.pure]<-"C"
		D3$WT10[anticyc.pure]<-"A"
		D3$WT10.num<-match(D3$WT10,WTs.type)# aggiunge l'ultima colonna con la conversione dei 10 tipi di tempo a numeri da 1 a 9 + il tipo A che si converte nel numero 18)

		#write.table(D3[,c("Year","Month","Day","WT")],file="C:/nicola/WTs_from_Emulate.txt",row.names=FALSE,col.names=FALSE,quote=FALSE)
		#write.table(D3[,c("Year","Month","Day","WT10.num")],file="C:/nicola/NCEP_10WTs.txt",row.names=FALSE,col.names=FALSE,quote=FALSE)
		#write.table(D3[,c("Year","Month","Day","WT.num")],file=output.WTs,row.names=FALSE,col.names=FALSE,quote=FALSE)
		write.table(D3[,c("Year","Month","Day","WT")],file="C:/nicola/tmp.txt",row.names=FALSE,col.names=FALSE,quote=FALSE)
		#write.table(D3[,c("Year","Month","Day","WT")],file=paste("C:\\nicola\\precipitaciones\\weather_types\\database WTs NCAR for Spain\\",point.name,sep=""),row.names=FALSE,col.names=FALSE,quote=FALSE)
		
		# Per salvare anche gli indici geostrofici:
		write.table(cbind(D3[,c("Year","Month","Day","WT")],D=round(D,3),D2=round(D2,3),F=round(F,3),Z=round(Z,3)),file=paste("C:\\nicola\\precipitaciones\\weather_types\\database WTs NCAR for Spain\\","Torino2.txt",sep=""),row.names=FALSE,col.names=TRUE,quote=FALSE)

		# Per salvare anche gli indici geostrofici per Dhais:
		write.table(cbind(D3[,c("Year","Month","Day","WT")],SF=round(SF,5),WF=round(WF,5),F=round(F,5),D=round(D2,5),ZS=round(ZS,5),ZW=round(ZW,5),Z=round(Z,5)),file=paste("C:\\nicola\\precipitaciones\\weather_types\\database WTs NCAR for Spain\\","WTs NCEP 1970-2013.txt",sep=""),row.names=FALSE,col.names=TRUE,quote=FALSE)

	} # chiude il for su point
		
	### visualizza il patron dei campi di pressione associati ai WTs calcolati:
	# ma non funziona perche c'e' un problema con proj4string(grd)
	npx.ori<-dim(standard.SLP.full)[2]-3
	listaWT.used<-D3[,c("Year","Month","Day","WT")]
	idWT<-sort(unique(listaWT.used[[4]])) # cosi' puoi trattare anche tipi di tempo numerici ma non interi
	 nWT=length(unique(listaWT.used[[4]])) # numero di tipi di tempo della classificazione (es: 8, 9 o 10)
	WorldPoly<- readShapePoly('C:/Projecto_Master/Limites Mundo/TM_WORLD_BORDERS-0.2.shp')
	proj4string(WorldPoly) <- CRS("+proj=longlat +datum=WGS84")
	my.polygon=list('sp.polygons',WorldPoly,first=F)
	my.layout=list(my.polygon) 
	gt = GridTopology(cellcentre.offset = angolo.basso.sinistra, cellsize = c(deg,deg), cells.dim = c(npx.ori, npx.ver)) 
	grd = SpatialGrid(gt)
	proj4string(grd) <- CRS("+proj=longlat +datum=WGS84")
	my.names<-nome.mese
	my.cuts<-c(0,0.01,0.15,0.3,0.5,1)
	#my.cuts<-c(0.1,3,10,20,100)^(1/3)
	my.labels<-c("1%","15%","30%","50%","100%")
	#my.labels<-c("1 mm","3%","10%","20%","100%")
	my.cuts.in.leyend<-c(0.01,0.15,0.30,0.50,1)
	my.colors<-c("transparent","#00FFFF","#0099F8","blue","purple")

	for(wt in WTs.type){ # cicla su tutti i WTs
		#es: wt="NE" # scegli il tipo di tempo da mappare se non fai il ciclo for
		wt.num<-which(WTs.type==wt) # converte il wt espresso come lettera in numero da 1 a 26

		# usa la classificazione dei WT giornalieri scelta all'inizio e i campi di pressione giornalieri del database file.SLP (in formato standard) da cui
		# si e' eseguito il downscaling della classificazione in uso e li converte in mappe di pressione media associata ad ogni WT in tutta l'area di studio del database di pressione:
		datos.SLP2<-standard.SLP.full #database pressione giornaliera nel formato anno/mese/giorno/valori di pressione dei pixel in colonne	
		datos.SLP2$WT<-rep(listaWT.used[[4]],each=npx.ver) # aggiunge a destra di datos.SLP2 una colonna con il tipo di tempo corrispondente
		pressure.WT.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,npx.ori*npx.ver)), proj4string = CRS("+proj=longlat +datum=WGS84"))

		datos.temp<-datos.SLP2
		datos.temp<-subset(datos.temp,datos.temp$WT==idWT[wt.num])
		n.dias<-dim(datos.temp)[1]/npx.ver
		mean.pressure<-data.frame(array(0,c(npx.ver,npx.ori)))
		for(d in 1:n.dias){
			mean.pressure<-mean.pressure+datos.temp[(npx.ver*(d-1)+1):(npx.ver*d),4:(3+npx.ori)]
		}
		mean.pressure<-mean.pressure/n.dias # per calcolare la media invece de la somma
		# carica i dati di tutte le medie possibili in pressure.grid:
		pressure.WT.grid@data[[WTs.type[wt.num]]]=as.numeric(t(mean.pressure))

		# campi di pressione del WT considerato senza grid colorato sotto ma solo con linee di livello blu:
		my.main=list(label=WTs.names.long[wt.num],cex=1.1)
		spplot(pressure.WT.grid,wt,sp.layout=my.layout,contour=TRUE,col='blue',labels=F,region=F, main=my.main,xlim=c(-20,10),ylim=c(30,50)) # mappa campi di pressione
		
		# centered on Torino:
		spplot(pressure.WT.grid,wt,sp.layout=my.layout,contour=TRUE,col='blue',labels=F, cuts=30,lwd=1.5,col.regions=rev(jet.colors(1000)),main=my.main,xlim=c(-7.5,22.5),ylim=c(35,55)) # mappa campi di pressione

		# campi di pressione del WT considerato con grid rosso e blu e linee di livello bianche:
		my.WT.map<-spplot(pressure.WT.grid,wt,sp.layout=my.layout,contour=TRUE,col='gray',region=FALSE,labels=FALSE,
					cuts=30,lwd=1.5,col.regions=rev(jet.colors(1000)),main=my.main,xlim=c(-35,25),ylim=c(25,60)) # colorkey=list(space = "bottom"),cuts=30,
		# campi di pressione con grid rosa bianco azzurro e linee di livello grigio:
		my.WT.map<-spplot(pressure.WT.grid,wt,sp.layout=my.layout,contour=TRUE,col='gray',labels=F,
				colorkey=list(space = "bottom"),main=my.main,xlim=c(-20,10),ylim=c(30,50)) # mappa campi di pressione del WT considerato
	}
	
	# # confronto WTs Ensemble de Alex y WTs Ensemble de Nic:
	# nic<-read.table("C:/nicola/precipitaciones/weather_types/26 WTs from begin year to end/WTs_from_EMULATE_nic.txt",stringsAsFactors=FALSE,header=FALSE) # legge tutti i dati giornalieri di SLP
	# nic[,5]<-nic[,4]
	# number.WTs.nic<-c(1:26)
	# for(i in 1:26)nic[,5]<-replace(nic[,5],which(nic[,5]==number.WTs.nic[i]),WTs.type[i])
	# alex<-read.table("C:/nicola/precipitaciones/weather_types/26 WTs from begin year to end/EMULATE Project.txt",stringsAsFactors=FALSE,header=FALSE) # legge tutti i dati giornalieri di SLP
	# alex[,5]<-alex[,4]
	# number.WTs.alex<-c(1,2,3,4,5,6,7,8,30,31.5,32.5,33.5,34.5,35.5,36.5,37.5,38.5,40,41.5,42.5,43.5,44.5,45.5,46.5,47.5,48.5)
	# # ricordati che WTs.type<-c("NE","E","SE","S","SW","W","NW","N","C","C.NE","C.E","C.SE","C.S","C.SW","C.W","C.NW","C.N","A","A.NE","A.E","A.SE","A.S","A.SW","A.W","A.NW","A.N") 
	# for(i in 1:26)alex[,5]<-replace(alex[,5],which(alex[,5]==number.WTs.alex[i]),WTs.type[i])
	# alex[,6]<-nic[,5]
	# alex[,7]<-D
	# alex[,8]<-D2
	# alex[1:200,]
	# save.image(paste(dir_root,"/RData/125_cfr_downscaling_Alex_y_Nic.RData",sep=""))
}

################################## IMPORTA L'INFOFILE DI PREC E I DATI DI PREC ##############################################################################################
 #importa il file di excel con elenco di tutte le stazioni disponibili:
infofile <- read.xls(dir_infofile,verbose=TRUE,fill=TRUE,header=T,skip=0,na.strings="-999",perl=perlexe,stringsAsFactors=FALSE)
names(infofile)<-c("CODIGO","NOMBRE","PROVINCIA","LATITUDE","LONGITUDE","ALTITUDE")

infofile<-subset(infofile,infofile[[1]]!="") #borra le eventuali filas vacias
ss<-which(substring(infofile[[2]],1,1)==" ") #borra el eventuale primero espacio de los nombres de las estaciones que empiezan con un espacio " "
for (i in ss)infofile[[2]][i]=substring(infofile[[2]][i],2,nchar(infofile[[2]][i]))
tt<-which(substring(infofile[[2]],1,1)==".") #borra el eventual primer character en los nombres de las estaciones que empiezan con un punto "."
for (i in tt)infofile[[2]][i]=substring(infofile[[2]][i],2,nchar(infofile[[2]][i]))

#infofile<-infofile[order(infofile[[2]],infofile[[3]],infofile[[4]]),] #ordina per nome stazione, provincia e anno
infofile<-infofile[order(infofile[[1]]),] #ordina per CODIGO (se non lo e' gia')
staz.infofile<-infofile[[1]] # elenco codici stazioni infofile in ordine alfanumerico
n.staz.infofile<-dim(infofile)[1]

# importa i dati di tutte le stazioni elencate e converti i manca-dato -999 in NA:
# (stavolta non c'e' bisogno di fare un for per ogni stazione della lista perche' si suppone che tutti e solo i dati delle stazioni nella lista stiano nello stesso file di dati .txt):
separator="";if(substring(dir_datos,nchar(dir_datos),nchar(dir_datos))=="v")separator=";" # solo se importi un .csv
dati<-read.table(dir_datos,header=header_datos,stringsAsFactors=FALSE,na.strings="-999",sep=separator) 
names(dati)<-c("Codigo","Year","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec")

# convert monthly data to seasonal data:
if(seasons==TRUE){
	dati.seasonal=dati
	if(predictand=="TEMP"){mod.pred=3}else{mod.pred=1}  # in case of temperature we need the mean of the monthly values , not the cumulated value as for the precip.
	dati.seasonal[,3]=sum(dati[,11]+dati[,12]+dati[,13])/mod.pred # Autumn
	dati.seasonal[,4]=sum(dati[,3]+dati[,4]+dati[,14])/mod.pred # Winter
	dati.seasonal[,5]=sum(dati[,5]+dati[,6]+dati[,7])/mod.pred # Spring
	dati.seasonal[,6]=sum(dati[,8]+dati[,9]+dati[,10])/mod.pred # Summer
	names(dati.seasonal)<-c("Codigo","Year",name.seasons)
	dati<-dati.seasonal
	remove(dati.seasonal)
	# da qui in poi non ho piu implementato l' algoritmo per utilizzare i dati stagionai; devo ancora comvertire per esempio i tipi di tempo da mensili a stagionali
}

# RITAGLI DATI DI PREC: 
 # toglie uno alla prec.di ogni mese perche' nel database si era aggiunto 1 a tutti i valori per evitare mesi con zero: (funziona anche se ci sono NA)
if(piu_1==TRUE){for(m in 1:n.mesi)dati[[2+m]]<-dati[[2+m]]-1 }
# se ci sono valori uguali a -1 (erano dei vecchi zero che dovevano essere messi ad 1) li mette uguali a zero:
for(m in 1:n.mesi){ss<-which(dati[[2+m]]==-1);dati[[2+m]][ss]=0}
# toglie l'anno 2006 alle prec.di ogni serie perche' nel database MOPREDAS compare sempre senza dati:
if(remove_2006==TRUE)dati<-subset(dati,dati[[2]]!=2006)
# se i dati sono espressi in decimi di mm, divide la prec. per 10:
if(dec_mm==T)dati[,3:(2+n.mesi)]=dati[,3:(2+n.mesi)]/10

dati<-dati[order(dati[[1]],dati[[2]]),] #ordina per codigo e anno
staz.dati<-unique(dati[[1]]) # unique serve a eliminare gli stessi codici che si ripetono per ogni anno nel file di dati
n.staz.dati<-length(staz.dati)

# toglie i dati delle serie che non sono in infofile (confrontando i codici):
#(e' normale, di solito nel file di dati si riversa tutto il database disponibile, e nel infofile solo le stazioni con le quali lavorare)
dati<-subset(dati,dati[[1]] %in% staz.infofile) # cioe' estrae le righe in cui il codice appartiene alla lista di codici in staz.infofile!

# numero ed elenco stazioni finali dopo la selezione: (normalmente coincide con il numero di stazioni di infofile, ma potrebbe essere di meno se ci sono stazioni nell'infofile che non sono presenti anche nei dati)
listaz<-unique(dati[[1]]);n.staz<-length(listaz)
if(n.staz!=n.staz.infofile)stop("Attenzione: alcune serie dell'infofile non sono presenti nel file di dati")

# ora devi formattare le stazioni rimaste, cioe' fare in modo che tutte quante comincino e finiscano con gli stessi anni:
min.assoluto<-min(dati[[2]])
max.assoluto<-max(dati[[2]])
for(st in listaz){
	st.dati<-subset(dati,dati[[1]]==st)
	st.min<-min(st.dati[[2]])
	st.max<-max(st.dati[[2]])
	if(st.min>min.assoluto){ # se la stazione comincia piu'tardi del normale bisgona aggiungere prima delle file con NA
		n.years.new<-st.min-min.assoluto # conta quanti anni si manca-dati bisogna aggiungere
		st.new<-as.data.frame(cbind(rep(st,n.years.new),c(min.assoluto:(st.min-1)),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new)),stringsAsFactors=FALSE)
		st.new[[2]]<-as.numeric(st.new[[2]]) # rimette gli anni come numeri perche' erano stati convertiti a char nel creare il data.frame
		dimnames(st.new)[[2]]<-c("Codigo","Year","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec")
		dati<-rbind(dati,st.new) # file di manca-dato 
	}
	if(st.max<max.assoluto){
		n.years.new<-max.assoluto-st.max
		st.new<-as.data.frame(cbind(rep(st,n.years.new),c((st.max+1):max.assoluto),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new),rep(NA,n.years.new)),stringsAsFactors=FALSE)
		st.new[[2]]<-as.numeric(st.new[[2]]) # rimette gli anni come numeri perche' erano stati convertiti a char nel creare il data.frame
		dimnames(st.new)[[2]]<-c("Codigo","Year","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec")
		dati<-rbind(dati,st.new)
	}
}
dati<-dati[order(dati[[1]],dati[[2]]),] #ordina di nuovo per codigo e anno perche' abbiamo aggiunto delle file in fondo

n.years<-tot.regr<-end.regr-start.regr+1 # numero di anni per fare le analisi di regression
period<-start.regr:end.regr 

####################### IMPORTA i WTs E LI TRASFORMA DA GIORNALIERI A MENSILI E CALCOLA LA FREQUENZA ######################################################################

 #importa tutti i file DI TESTO con le classificazioni di tipi di tempo: (nel formato anno / mese / giorno / tipo di tempo)
setwd(dir_WT)
classi<-list.files(pattern="*.txt")
n.classi=length(classi) # numero di classificazioni dei WT (cioe' numero di file)
nome.classe<-substr(classi,1,nchar(classi)-4) #toglie il .txt alla fine del nome ogni classe
listaWT<-list();idWT<-list()
nWT<-c() # vettore con il numero di tipi di tempo per ogni classificazione

i=1
for(x in classi){
	listaWT[[i]]<- read.table(paste(dir_WT,x,sep="/"),stringsAsFactors=FALSE,header=FALSE)
        names(listaWT[[i]])=c("Year","Month","Day","WT")
	 idWT[[i]]<-sort(unique(listaWT[[i]][[4]])) # cosi' puoi trattare anche tipi di tempo numerici ma non interi
	 nWT[i]=length(unique(listaWT[[i]][[4]])) # numero di tipi di tempo della classificazione (es: 8, 9 o 10)
	 i<-i+1
 }
max.nWT<-max(nWT) # indica il numero massimo di tipi di tempo per tutte le classificazioni

begin.month<-begin.day<-begin.year<-end.month<-end.day<-end.year<-tot.years<-c() # vettori che conterranno le date iniziali e finali per ogni classificazione

monthlyWT<-list() # lista definitiva che conterra' per ogni classificazione una matrice con il numero di eventi mensili
                                   # per ogni WT per lo stesso anno e mese; il formato e' del tipo anno / mese / WT1 / WT2 / ... / WTn
				   # nota che e' in questa fase che i WTs passano dalla notazione indigena originaria (per es, per il database Emulate, numeri anche seminteri come 41.5)			   
				   # alla notazione intera crescente (da 1 a 26 per l'Emulate) che verra' mantenuta in tutte le analisi. A questa notazione viene anche
				   # associato il nome del tipo di tempo nel vettore WTs.type (es, il numero 1 diventa il NE, ecc.), che va bene sia per il 
				   # database Emulate che per il database NCEP. Nel caso un altro database segua una corrispondenza numeri-nomi WTs differente,
				   # bisogna adattare il vettore WTs.type! (magari in futuro puoi spostarlo tra le variabili all'inizio dello script)

if(weekly==FALSE){ # se vuoi raggruppare i WTs per mesi:		   
	barraP<-winProgressBar("Analyzing data","Please wait...",0,n.classi,0)
	for(cla in cla.rif){ # in futuro se vuoi rimetti cla in 1:n.classi
		begin.month[cla]=listaWT[[cla]][[2]][1]
		begin.day[cla]=listaWT[[cla]][[3]][1]
		begin.year[cla]=listaWT[[cla]][[1]][1]
		if(begin.month[cla]>1 | begin.day[cla]>1)begin.year[cla]<-begin.year[cla]+1 # se il primo anno non ha tutti i dati inizia dall'anno seguente (per es. il database Cost inizia il 1/9/1957)

		end.month[cla]=listaWT[[cla]][[2]][length(listaWT[[cla]][[1]])]
		end.day[cla]=listaWT[[cla]][[3]][length(listaWT[[cla]][[1]])]
		end.year[cla]=listaWT[[cla]][[1]][length(listaWT[[cla]][[1]])] 
		if(end.month[cla]<12 | end.day[cla]<endmonth(end.day[cla],end.month[cla],end.year[cla]))end.year[cla]<-end.year[cla]-1 # toglie un anno se l'ultimo anno non ha tutti i dati

		# trasforma i dati dei WT da giornalieri a mensili (x e' il vettore che di volta in volta contiene tutti i WT giornalieri dello stesso mese):
		tot.years[cla]<-end.year[cla]-begin.year[cla]+1
		years<-begin.year[cla]:end.year[cla]
		seq.years<-c();for(y in years) seq.years<-c(seq.years,rep(y,12))
		seq.months<-rep(1:12,tot.years[cla])

		monthlyWT[[cla]]=matrix(NA,tot.years[cla]*12,2+nWT[cla]) # colonna anno, mese piu' le colonne per i WT
		monthlyWT[[cla]][,1]=seq.years
		monthlyWT[[cla]][,2]=seq.months

		for(y in years){
		  for(m in  1:12){
		   x<-subset(listaWT[[cla]],listaWT[[cla]]$Year==y & listaWT[[cla]]$Month==m,select=4)
		   for(wt in 1:nWT[cla]) monthlyWT[[cla]][m+(y-begin.year[cla])*12,2+wt]=length(which(x==idWT[[cla]][[wt]]))
		  }
		 }
		 setWinProgressBar(barraP,cla)
	};close(barraP)

} else {# raggruppamento per settimane invece che per mesi:
	monthlyWT<-list() # lista definitiva che conterra' per ogni classificazione una matrice con il numero di eventi per ogni WT
					# nello stesso "anno" (in realta' un anno corrisponde ad una settimana ed e' un numero da 1 fino a XXX).
					# Il formato e' sempre "anno" / mese / WT1 / ... / WTn 
					# ma stavolta il mese e' una variabile inutile perche tutti i mesi hanno gli stessi conteggi dei WTs

	begin.month[cla.rif]=listaWT[[cla.rif]][[2]][1] # primo mese di dati
	begin.day[cla.rif]=listaWT[[cla.rif]][[3]][1]
	begin.year[cla.rif]=listaWT[[cla.rif]][[1]][1]
	if(begin.month[cla.rif]>1 | begin.day[cla.rif]>1)begin.year[cla.rif]<-begin.year[cla.rif]+1 # se il primo anno non ha tutti i dati inizia dall'anno seguente (per es. il database Cost inizia il 1/9/1957)

	end.month[cla.rif]=listaWT[[cla.rif]][[2]][length(listaWT[[cla.rif]][[1]])]
	end.day[cla.rif]=listaWT[[cla.rif]][[3]][length(listaWT[[cla.rif]][[1]])]
	end.year[cla.rif]=listaWT[[cla.rif]][[1]][length(listaWT[[cla.rif]][[1]])] 
	if(end.month[cla.rif]<12 | end.day[cla.rif]<endmonth(end.day[cla.rif],end.month[cla.rif],end.year[cla.rif]))end.year[cla.rif]<-end.year[cla.rif]-1 # toglie un anno se l'ultimo anno non ha tutti i dati

	# trasforma i dati dei WT da giornalieri a settimanali:
	monthlyWT[[cla.rif]]=matrix(NA,end.analisi*12,2+nWT[cla.rif]) # colonna anno, mese piu' le colonne per i WT
	
	for(i in 1:end.analisi){
		week<-listaWT[[cla.rif]][((i-1)*7+1):(i*7),4]
		for(wt in 1:nWT[cla.rif])monthlyWT[[cla.rif]][(i-1)*12+1,2+wt]=length(which(week==idWT[[cla.rif]][[wt]]))
		for(j in 2:12){
			monthlyWT[[cla.rif]][(i-1)*12+j,3:(2+nWT[[cla.rif]])]=monthlyWT[[cla.rif]][(i-1)*12+1,3:(2+nWT[[cla.rif]])]
		}
	}
	
	monthlyWT[[cla.rif]][,1]<-rep(c(1:end.analisi),each=12) # aggiunge la colonna con gli anni
	monthlyWT[[cla.rif]][,2]<-rep(1:12) # aggiunge la colonna con i mesi
	
} # chiude l'if su weekly

if(contaminantes==TRUE){ # i WTs vengono sostituiti dai 5 contaminanti
	nWT[cla.rif]<-5

	temp<-read.table(contam,header=TRUE,stringsAsFactors=FALSE)
	temp2<-c()
	for(mes in 1:12){ # aggiunge una colonna alla fine con il mese
		if(mes>1){temp2<-rbind(temp2,cbind(temp,mes))} else {temp2<-cbind(temp,mes)}
	}
	temp2<-temp2[,c(1,7,2:6)] # sposta la colonna con i mesi in seconda posizione
	monthlyWT[[cla.rif]]<-temp2[order(temp2[,1],temp2[,2]),] # ordina in base alla colonna degli anni e dei mesi in modo che sia uguale al formato di monthlyWT
}

# recalculate monthlyWTs if they are 10:
if(n.weather.types==10){
	monthlyWT[[cla.rif]][,3]=monthlyWT[[cla.rif]][,3]+monthlyWT[[cla.rif]][,12]+monthlyWT[[cla.rif]][,21] # NE
	monthlyWT[[cla.rif]][,4]=monthlyWT[[cla.rif]][,4]+monthlyWT[[cla.rif]][,13]+monthlyWT[[cla.rif]][,22] # E
	monthlyWT[[cla.rif]][,5]=monthlyWT[[cla.rif]][,5]+monthlyWT[[cla.rif]][,14]+monthlyWT[[cla.rif]][,23] # SE
	monthlyWT[[cla.rif]][,6]=monthlyWT[[cla.rif]][,6]+monthlyWT[[cla.rif]][,15]+monthlyWT[[cla.rif]][,24] # S
	monthlyWT[[cla.rif]][,7]=monthlyWT[[cla.rif]][,7]+monthlyWT[[cla.rif]][,16]+monthlyWT[[cla.rif]][,25] # SW
	monthlyWT[[cla.rif]][,8]=monthlyWT[[cla.rif]][,8]+monthlyWT[[cla.rif]][,17]+monthlyWT[[cla.rif]][,26] # W
	monthlyWT[[cla.rif]][,9]=monthlyWT[[cla.rif]][,9]+monthlyWT[[cla.rif]][,18]+monthlyWT[[cla.rif]][,27] # NW
	monthlyWT[[cla.rif]][,10]=monthlyWT[[cla.rif]][,10]+monthlyWT[[cla.rif]][,19]+monthlyWT[[cla.rif]][,28] # N
	nWT[cla.rif]=10

	tmp<-as.matrix(cbind(monthlyWT[[cla.rif]][,1],monthlyWT[[cla.rif]][,2],monthlyWT[[cla.rif]][,3],monthlyWT[[cla.rif]][,4],monthlyWT[[cla.rif]][,5],monthlyWT[[cla.rif]][,6],monthlyWT[[cla.rif]][,7],monthlyWT[[cla.rif]][,8],monthlyWT[[cla.rif]][,9],monthlyWT[[cla.rif]][,10],monthlyWT[[cla.rif]][,11],monthlyWT[[cla.rif]][,20]))
	
	monthlyWT[[cla.rif]]<-tmp
	remove(tmp)
}


# Calcolo della frequenza dei WTs mensili per due periodi diversi:

A<-list() # A e' una lista di liste mensili delle matrici dei WT per la classificazione di riferimento (un mese per matrice); formato: anno/mese/WT1/WT2/...
AN<-list() # come A ma inizia e finisce in un periodo scelto dall'utente per fare le analisi dei WTs; le frequenze non sono ancora in % ma in num.di giorni al mese
for(cla in  cla.rif){ #2:n.classi){ # tolgo temporaneamente la cla num.1 perche'comincia dopo il 1850
  A[[cla]]<-list();AN[[cla]]<-list()
  for(mese in 1:12)A[[cla]][[mese]]<-subset(monthlyWT[[cla]],monthlyWT[[cla]][,2]==mese)
  for(mese in 1:12)AN[[cla]][[mese]]<-A[[cla]][[mese]][A[[cla]][[mese]][,1]>=begin.analisi & A[[cla]][[mese]][,1]<=end.analisi,]
}

# Calcola la media mensile sul periodo impostato sopra del numero di giorni appartenenti ad ogni WT:
AN.day.mean<-AN.mean<-AN.msd<-array(NA,c(n.classi,nWT[cla.rif],12),dimnames<-list(classi,WTs.type,nome.mese)) # msd e' la deviazione standard della media (=dev.stnd/radice(num.misure))
for(cla in cla.rif){  # 2:n.classi){ tolgo temporaneamente la cla num.1 perche'comincia dopo il 1850
for(wt in 1:nWT[cla]){
for(mese in 1:12){
	AN.day.mean[cla,wt,mese]<-mean(AN[[cla]][[mese]][,2+wt]) # media della frequenza dei WTs mensili espressi pero' come numero di giorni al mese, non come %
	temp<-AN[[cla]][[mese]][,2+wt] # ovvero temp<-AN.day.mean[cla,wt,mese]
	AN.mean[cla,wt,mese]<-100*mean(temp)/lastday(mese,1) # il denominatore serve per passare alla frequenza in %, cioe' per passare dal numero medio di eventi mensili alla frequenza media in % del numero di giorni di WTs
	AN.msd[cla,wt,mese]<-(100*sd(temp)/lastday(mese,1))/(end.analisi-begin.analisi+1)^0.5
}}}
#plot(AN.day.mean[cla,26,],type="b")

# calcola il trend delle frequenze per ogni mese e WT e il p-value con Mann-Kendall:
trend<-p.val<-mean.fr<-Z<-array(NA,c(12,nWT[cla.rif]),dimnames=list(nome.mese,WTs.names[[1]]))
for(wt in 1:nWT[cla.rif]){ 
	for(mese in 1:12){ #int.mesi){  
	   x<-begin.analisi:end.analisi
	   y<-AN[[cla]][[mese]][,2+wt]
	   
	  reg<-lm(y~x)    #linear fit de los puntos
	  slope<-reg$coefficients[2]     #estrae la pendenza della retta di regressione
	  trend[mese,wt]<-slope*length(x)  # calcola la tendenza per il periodo impostato
	  suppressWarnings(k<-Kendall(x,y)) # nota che se mette un warning: Error.exit, tauk2=FAULT e' perche la Kendall(x,y) restituisce 1 perche' y e' un vettore di zeri
	  p.val[mese,wt]<-k$sl[1]    # estrae il p-value a due code

	 S=k$S[1] # statistica S di Kendall
	 VS=k$varS[1] # varianza di S
	 if(S>0)Z[mese,wt]=(S-1)/(VS^0.5);if(S==0)Z[mese,wt]=0;if(S<0)Z[mese,wt]=(S+1)/(VS^0.5) # statistica Z o tau di Kendall
	  
	  mean.fr[mese,wt]<-AN.day.mean[cla.rif,wt,mese]
	 }
}

p.val<-t(round(p.val,2))   # visualizza solo due cifre decimali del p-value)
trend<-t(round(trend,2)) # trend della frequenza (espressa come numero di giorni al mese del WT considerato) su tutto il periodo impostato
mean.fr<-t(round(mean.fr,2));Z<-t(round(Z,3)) #espressa in numero di giorni al mese
#t(round(mean.contribute,2)) # occhio che mean.contribute si calcola solo dopo alla fine dello script, qui l'ho messo solo se si vuole visualizzarlo assieme a mean.fr!

 if(altro==TRUE){
 
 # analisi multicollinearity (correlazioni tra WTs) nel periodo di riferimento:
multic<-c()
for(mese in 1:12){
	cor.threshold=0.3 # valore minimo di correlazione tra due WTs per avere multicollinearity
	C<-round(cor(AN[[cla.rif]][[mese]][,-c(1,2)],AN[[cla.rif]][[mese]][,-c(1,2)]),2) # toglie da AN le prime due colonne con l'anno e il termine noto
	dimnames(C)<-list(WTs.type,WTs.type)
	C.max<-which(C>cor.threshold & C<1,arr.ind=T)
	C.cor<-cbind(rep(mese,dim(C.max)[1]),dimnames(C)[[1]][C.max[,1]], dimnames(C)[[1]][C.max[,2]],C[C.max])
	n.rig<-dim(C.cor)[1]
	if(n.rig>=2){
		ripetuto<-rep(FALSE,n.rig)
		for(i in 2:n.rig){
			for(j in 1:i){
				if(C.max[j,1]==C.max[i,2] & C.max[j,2]==C.max[i,1])ripetuto[i]<-TRUE
			}
		}
		C.cor<-C.cor[ripetuto==FALSE,] # seleziona solo le righe che non sono ripetute
		multic<-rbind(multic,C.cor)
	}
	row.names(multic)<-NULL
}
multic<-multic[order(multic[,4],decreasing=TRUE),]
multic<-multic[,c(4,1,2,3)] # porta la colonna con la correlazione in prima posizione
dimnames(multic)<-list(NULL,c("correl","mese","WT1","WT2"))

##### confronta le frequenze mensili per due periodi a scelta:
p1.start=1945
p1.end=1974
p2.start=1975
p2.end=2003

p1.length=p1.end-p1.start+1
p2.length=p2.end-p2.start+1

colnames(monthlyWT[[cla.rif]])<-c("year","month",WTs.type)
monWT<-data.table(monthlyWT[[cla.rif]],key="year,month")

monWT$period<-NA
rows1<-which(monWT$year>=p1.start & monWT$year<=p1.end)
rows2<-which(monWT$year>=p2.start & monWT$year<=p2.end)
monWT$period[rows1]<-1
monWT$period[rows2]<-2

setkey(monWT,period)
monWT2<-monWT[,lapply(.SD,sum),by=list(month,period),.SDcols=3:28]
monWT2[period==1]
monWT2[period==2]
# il primo metodo si puo applicare solo a:
monWT2[period==1,3:28,with=F]>5 & monWT2[period==2,3:28,with=F]>5
temp<-monWT2[period==1]>5 & monWT2[period==2]>5
ss<-which(temp==F)

n1<-(30.4*p1.length) # numero medio di giorni per mese; non ? precisissimo ; correggi in futuro!
n2<-(30.4*p2.length)
p1<-monWT2[period==1]/n1
p2<-monWT2[period==2]/n2
p<-(monWT2[period==1]+monWT2[period==2])/(n1+n2)
options(scipen=999) # elimina la notazione scentifica dei numeri (esponenziale)

# metodo che funziona se n1*p1>5 e n2*p2>5 e n1>=50 e n2>=50 (p1=x1/n1)
z<-abs(p1-p2)/(p*(1-p)*((1/n1)+(1/n2)))^0.5 
z<-as.matrix(z)
z<-pnorm(z,lower.tail=F) # calcola i p-value, noto z (non moltiplichiamo per due perche sappiamo gia se la frequenza ? aumentata o diminuita, cioe sappiamo gi? quale delle due code stiamo calcolando)
z[ss]<-NA
z<-z[,-c(1,2)] # toglie le prime due colonne
z<-round(z,2)
z

 # metodo basato nella trasformazione arcsen che funziona per n1*p1>=1 y n2>=25     {z<-abs(asin((p1)^0.5)-asin((p2)^0.5))/(28.648*((1/n1)+(1/n2))^0.5)}
z2<-abs(p1-p2)/((p1*(1-p1)/n1)+(p2*(1-p2)/n2))^0.5
z2<-as.matrix(z2)
z2<-pnorm(z2,lower.tail=F) # calcola i p-value, noto z2 
temp2<-monWT2[period==1]>=1
ss2<-which(temp2==F)
z2[ss2]<-NA
z2<-z2[,-c(1,2)] # toglie le prime due colonne
z2<-round(z2,2)
z2

# nuova classificazione WTs in 10 tipi:
monWT3<-monWT2[,c("month","period","C","A"),with=F]
monWT3$NE<-monWT2$NE+monWT2$C.NE+monWT2$A.NE
monWT3$E<-monWT2$E+monWT2$C.E+monWT2$A.E
monWT3$SE<-monWT2$SE+monWT2$C.SE+monWT2$A.SE
monWT3$S<-monWT2$S+monWT2$C.S+monWT2$A.S
monWT3$SW<-monWT2$SW+monWT2$C.SW+monWT2$A.SW
monWT3$W<-monWT2$W+monWT2$C.W+monWT2$A.W
monWT3$NW<-monWT2$NW+monWT2$C.NW+monWT2$A.NW
monWT3$N<-monWT2$N+monWT2$C.N+monWT2$A.N

# applichiamo di nuovo il metodo 2 alla nuova classifiazione:
p1<-monWT3[period==1]/n1
p2<-monWT3[period==2]/n2
p<-(monWT3[period==1]+monWT3[period==2])/(n1+n2)
z2<-abs(p1-p2)/((p1*(1-p1)/n1)+(p2*(1-p2)/n2))^0.5
z2<-as.matrix(z2)
z2<-pnorm(z2,lower.tail=F) # calcola i p-value, noto z2 
temp2<-monWT3[period==1]>=1
ss2<-which(temp2==F)
z2[ss2]<-NA
z2<-z2[,-c(1,2)] # toglie le prime due colonne
z2

#p2-p1 per vedere se la freq. aumenta o diminuisce passando dal primo al secondo periodo
segno<-(p2-p1)[,-c(1,2),with=F]
ss<-which(segno<0)
z2[ss]<-z2[ss]*(-1)
z2<-round(z2,7)
z2

# to replace numbers with colours: 
df<-data.frame(x=c("A","B","C"),colour=c(0.3,0.6,0.9))
breaks <- c(0.4, 0.7)  # you can add more cut points here
cols <- brewer.pal(length(breaks) + 1, "Greens")
df$colour <- as.character(cut(df$colour, c(-Inf, breaks, Inf), labels=cols))


#### MAPPE POSTER WTs ####################################################################

# MAPPA 1: per ogni classificazione e per ogni tipo di tempo, calcola per ogni mese la % del numero medio di giorni con quel WT per l'intero periodo della matrice A:
par(mfrow=c(4,7));par(oma=c(2,2,2,2));  par(mar=c(1.5,1,1,1)) # oma controlla il bordo esterno a tutti i grafico, mar i bordi interni tra grafici
for(wt in 1:max.nWT){
# disegna il grafico a barre ma senza l'asse y: (# la seconda opzione di mgp derermina la distanza dei numeri dagli assi) # xlab="months",border="darkblue"
gbarre<-barplot(AN.mean[,wt,],beside=TRUE,ylim=c(0,30),col = c("blue", "red"),names.arg=c("J","F","M","A","M","J","J","A","S","O","N","D"),cex.names=0.6,xpd=F,axes=FALSE,mgp=c(3,0,0)) 
axis(2,cex.axis=0.6,tcl=-0.2) # aggiunge l'asse Y (il numero 2 crea un asse a sinistra) e ridimensiona la grandezza dei caratteri e delle tacche (valore default per tcl= -0.5, il meno indica che la tacca e' rivolta a sinistra)
box() # disegna un box intorno al grafico (par(lty="o") non funziona)
arrows(-1.5+3*(1:12),AN.mean[1,wt,]-AN.msd[1,wt,],-1.5+3*(1:12),AN.mean[1,wt,]+AN.msd[1,wt,],length=0.01,angle=90,code=3,col="lightseagreen") # barra d'errore per la prima serie
arrows(-0.5+3*(1:12),AN.mean[2,wt,]-AN.msd[2,wt,],-0.5+3*(1:12),AN.mean[2,wt,]+AN.msd[2,wt,],length=0.01,angle=90,code=3,col="coral") # barra d'errore per la seconda serie
title(WTs.names[[1]][wt],line=0.3)
}
lista.classif<-paste(nome.classe,collapse=" and the ")
title(paste("Comparison between the mean monthly percentage of WTs using the ",lista.classif," database for ",begin.analisi,"-",end.analisi," period.",sep=""),outer=TRUE) # outlier serve per disegnare il titolo fuori dall'area dei pannelli
plot(1:12,1:12,type="n",axes=F);plot(1:12,1:12,type="n",axes=F) # mette due plot in bianco per arrivare in fondo a destra dello schermo
legend(-2.5,10,nome.classe, cex=1.5, bty="n", fill=c("blue", "red"),x.intersp=0.2) # i primi due numeri sono le coordinate della legenda, x.intersp e' la distanza tra i colori e il testo della legenda

# MAPPA 2: come prima, ma visualizza solo la serie temporale di uno o piu' mesi + media mobile di 5 anni:
mesinv<-c(10,11,12,1,2,3) # scegli 6 mesi da usare per definire la serie invernale (1 e' gennaio, 12 dicembre) SOLO per la Mappa 2
windows() # per mettere la mappa in una nuova finestra
AN.inv<-AN.inv.medmob<-list()
for(cla in 2:n.classi){   # tolgo temporaneamente la cla num.1 perche'comincia dopo il 1850
AN.inv[[cla]]<-AN.inv.medmob[[cla]]<-list()
for(wt in 1:max.nWT)AN.inv[[cla]][[wt]]<-AN[[cla]][[mesinv[1]]][,2+wt]+AN[[cla]][[mesinv[2]]][,2+wt]+AN[[cla]][[mesinv[3]]][,2+wt]+AN[[cla]][[mesinv[4]]][,2+wt]+AN[[cla]][[mesinv[5]]][,2+wt]+AN[[cla]][[mesinv[6]]][,2+wt]
for(wt in 1:max.nWT)AN.inv.medmob[[cla]][[wt]]<-filter(AN.inv[[cla]][[wt]],rep(0.2,5)) # 0.2 sono i coefficienti della media mobile di 5 anni
}
cla=cla.rif
par(mfrow=c(4,7));par(oma=c(2,2,2,2));  par(mar=c(2.5,1,1,1)) # oma controlla il bordo esterno a tutti i grafico, mar i bordi interni tra grafici
for(wt in 1:max.nWT){
plot(begin.analisi:end.analisi,AN.inv[[cla]][[wt]],type="l",cex=0.4,col="blue",ylim=c(0,max(AN.inv[[cla]][[wt]])),xlab="", ylab="")
par(new=TRUE)
plot(begin.analisi:end.analisi,AN.inv.medmob[[cla]][[wt]],type="l",cex=0.4,col="red",ylim=c(0,max(AN.inv[[cla]][[wt]])),xlab="", ylab="",lwd=2)
title(WTs.names[[1]][wt],line=0.3)
}
title(paste("Long-term variability of observed frequency (%) in Winter for ",nome.classe[cla]," database and ",begin.analisi,"-",end.analisi," period.",sep=""),outer=TRUE) # outlier serve per disegnare il titolo fuori dall'area dei pannelli

# MAPPA 3: come mappa 2, ma mostra solo la media mobile e per tutte le classificazioni sovrapposte:
windows() # per mettere la mappa in una nuova finestra
par(mfrow=c(4,7));par(oma=c(2,2,2,2));  par(mar=c(1.5,1,1,1)) # oma controlla il bordo esterno a tutti i grafico, mar i bordi interni tra grafici
for(wt in 1:max.nWT){
massimo<-max(AN.inv.medmob[[1]][[wt]],AN.inv.medmob[[2]][[wt]],na.rm=T)
plot(begin.analisi:end.analisi,AN.inv.medmob[[1]][[wt]],type="l",cex=0.4,col="red",ylim=c(0,massimo),xlab="", ylab="",lwd=2)
par(new=TRUE)
plot(begin.analisi:end.analisi,AN.inv.medmob[[2]][[wt]],type="l",cex=0.4,col="orange",ylim=c(0,massimo),xlab="", ylab="",lwd=2)
title(WTs.names[[1]][wt],line=0.3)
}
title(paste("5-days mobile mean of long-term variability of observed frequency (%) in Winter for all database and ",begin.analisi,"-",end.analisi," period.",sep=""),outer=TRUE) # outlier serve per disegnare il titolo fuori dall'area dei pannelli
plot(1:12,1:12,type="n",axes=F);plot(1:12,1:12,type="n",axes=F) # mette due plot in bianco per arrivare in fondo a destra dello schermo
legend(-2.5,10,nome.classe, cex=1.5, bty="n", fill=c("red", "orange"),x.intersp=0.2) # i primi due numeri sono le coordinate della legenda, x.intersp e' la distanza tra i colori e il testo della legenda

# MAPPA 4: come la mappa 1, ma visualizza solo i tipi di tempo della classificazione EMULATE
par(mfrow=c(4,7));par(oma=c(2,2,2,2));  par(mar=c(1.5,1,1,1)) # oma controlla il bordo esterno a tutti i grafico, mar i bordi interni tra grafici
for(wt in 1:max.nWT){
# disegna il grafico a barre ma senza l'asse y: (# la seconda opzione di mgp derermina la distanza dei numeri dagli assi) # xlab="months",border="darkblue"
gbarre<-barplot(AN.mean[2,wt,],beside=TRUE,ylim=c(0,30),col = c("grey40"),names.arg=c("J","F","M","A","M","J","J","A","S","O","N","D"),cex.names=0.6,xpd=F,axes=FALSE,mgp=c(3,0,0)) 
axis(2,cex.axis=0.6,tcl=-0.2) # aggiunge l'asse Y (il numero 2 crea un asse a sinistra) e ridimensiona la grandezza dei caratteri e delle tacche (valore default per tcl= -0.5, il meno indica che la tacca e' rivolta a sinistra)
box() # disegna un box intorno al grafico (par(lty="o") non funziona)
title(WTs.names[[1]][wt],line=0.3)
}
title(paste("Mean monthly percentage of WTs using the ",nome.classe[2]," database for ",begin.analisi,"-",end.analisi," period.",sep=""),outer=TRUE) # outlier serve per disegnare il titolo fuori dall'area dei pannelli
plot(1:12,1:12,type="n",axes=F);plot(1:12,1:12,type="n",axes=F) # mette due plot in bianco per arrivare in fondo a destra dello schermo

# MAPPA 5: come la mappa 2, ma visualizza la serie temporale per OGNUNO dei mesi in int.mesi e con media mobile di 21 anni:
AN.mese<-AN.mese.medmob<-list()
cla=cla.rif
for(mese in int.mesi){  
windows() # per mettere la mappa in una nuova finestra
AN.mese[[cla]]<-AN.mese.medmob[[cla]]<-list()
for(wt in 1:max.nWT)AN.mese[[cla]][[wt]]<-AN[[cla]][[mesinv[1]]][,2+wt]
for(wt in 1:max.nWT)AN.mese.medmob[[cla]][[wt]]<-filter(AN.mese[[cla]][[wt]],rep(1/21,21)) # 0.2 sono i coefficienti della media mobile di 5 anni

par(mfrow=c(4,7));par(oma=c(2,2,2,2));  par(mar=c(2.5,1,1,1)) # oma controlla il bordo esterno a tutti i grafico, mar i bordi interni tra grafici
for(wt in 1:max.nWT){
plot(begin.analisi:end.analisi,AN.mese[[cla]][[wt]],type="l",cex=0.4,col="blue",ylim=c(0,max(AN.mese[[cla]][[wt]])),xlab="", ylab="")
par(new=TRUE)
plot(begin.analisi:end.analisi,AN.mese.medmob[[cla]][[wt]],type="l",cex=0.4,col="red",ylim=c(0,max(AN.mese[[cla]][[wt]])),xlab="", ylab="",lwd=2)
title(WTs.names[[1]][wt],line=0.3)
}
title(paste("Long-term variability of observed frequency (%) in ",nome.mese[mese]," for ",nome.classe[cla]," database from ",begin.analisi," to ",end.analisi,sep=""),outer=TRUE) # outlier serve per disegnare il titolo fuori dall'area dei pannelli
}

# MAPPA 6: come la mappa 5, ma visualizza la serie temporale SOVRAPPONENDO ogni mese in int.mesi2 di uno o piu' mesi e con filtro gaussiano:
AN.mese<-AN.mese.medmob<-list()
cla=cla.rif
int.mesi2<-c(10,11,12) # puoi cambiarlo come vuoi es: int.mesi2<-int.mesi o int.mesi2<-c(10,3) o int.mesi2<-4
par(mfrow=c(4,5));par(oma=c(2,2,2,2));  par(mar=c(2.5,1.5,1.2,1)) # oma controlla il bordo esterno a tutti i grafici, mar i bordi interni tra grafici # ordine parametri: basso/sinistra/alto/destra
for(wt in 1:20 ){ #max.nWT){
	AN.mese[[cla]]<-AN.mese.medmob[[cla]]<-list()
	ymin<-ymax<-c()
	for(mese in int.mesi2) {#int.mesi){  
		AN.mese[[cla]][[wt]]<-AN[[cla]][[mese]][,2+wt]
		lll<-length(AN.mese[[cla]][[wt]])
		ymin[mese]<-min(ksmooth(1:lll,AN[[cla]][[mese]][,2+wt], "normal",bandwidth=years.filtro)$y)
		ymax[mese]<-max(ksmooth(1:lll,AN[[cla]][[mese]][,2+wt], "normal",bandwidth=years.filtro)$y)
	}
	ymin2<-min(ymin,na.rm=T);ymax2<-max(ymax,na.rm=T)

	plot(begin.analisi:end.analisi,rep(0,end.analisi-begin.analisi+1),type="n",cex=0.4,col="red",xlim=c(begin.analisi,end.analisi),ylim=c(ymin2,ymax2),xlab="", ylab="",lwd=2)
	title(WTs.names[[1]][wt],line=0.3)

	for(mese in int.mesi2){ #int.mesi){  
		AN.mese[[cla]][[wt]]<-AN[[cla]][[mese]][,2+wt]
		lll<-length(AN.mese[[cla]][[wt]])
		AN.mese.medmob[[cla]][[wt]]<-ksmooth(1:lll,AN.mese[[cla]][[wt]], "normal",bandwidth=years.filtro,n.points=lll) # filtro gaussiano!!! Sostituisce filter(AN.mese[[cla]][[wt]],rep(1/51,51),method="convolution")
		lines(begin.analisi:end.analisi,AN.mese.medmob[[cla]][[wt]]$y,cex=0.4,col=month.color2[mese],xlab="", ylab="",lwd=.5)
		#lines(begin.analisi:end.analisi,ksmooth(1:lll,AN.mese[[cla]][[wt]], "normal",bandwidth=5,n.points=lll)$y,cex=0.4,col=month.color2[mese],xlab="", ylab="",lwd=.1)
	}
}
title(paste("Long-term variability of WTs frequency for ",nome.classe[cla]," database from ",begin.analisi," to ",end.analisi,sep=""),outer=TRUE) # outlier serve per disegnare il titolo fuori dall'area dei pannelli
plot(begin.analisi:end.analisi,rep(0,end.analisi-begin.analisi+1),type="n",axes=F,xlab="", ylab="") # lascia un riquadro (panel) vuoto!!!
plot(begin.analisi:end.analisi,rep(0,end.analisi-begin.analisi+1),type="n",xlim=c(begin.analisi,end.analisi),ylim=c(0,10),axes=F,xlab="", ylab="")
legend(c(begin.analisi,end.analisi),c(10,0),nome.mese[int.mesi],col=month.color2[int.mesi],lwd=.2,bty="n",seg.len=1) # bty="n" toglie il frame attorno alla legenda
}

if(correl==TRUE){ ############################### CALCOLO CORRELAZIONI mensili tra serie di prec. ####################################################
# servira' per scegliere le stazioni per fare la LRK di tipo avanzato
# si calcola la correlazione tra i logaritmi delle serie temporali mensili per eliminare l'influenza degli outliers.

# toglie gli anni di dati delle stazioni mensili di prec.fuori dal periodo considerato per il calcolo delle correlazioni:
dati2<-subset(dati,dati[[2]]>=start.regr & dati[[2]]<=end.regr)
log.dati2<-log(1+dati2[,3:14]) # trasforma il database nel suo logaritmo naturale per poter calcolare poi le correlazioni (aggiunge 1 per non avere mai valori negativi)

# crea la matrice con il logoritmo delle correlazioni tra coppie di serie per ogni mese: (aggiungendo uno per non avere valori negativi del logaritmo)
log.cor<-array(NA,c(n.staz,n.staz,12),dimnames=list(listaz,listaz,nome.mese))

barraP<-winProgressBar("Calculating correlations","Please wait...",0,n.staz,0)
for(st1 in 1:(n.staz-1)){
	rows1<-(1:n.years)+(st1-1)*n.years
	for(st2 in (st1+1):n.staz){ 
		rows2<-(1:n.years)+(st2-1)*n.years
		for(mese in 1:12){
			log.cor[st1,st2,mese]<-.Internal(cor(log.dati2[rows1,mese],log.dati2[rows2,mese],5L,FALSE))
		}
	}
	setWinProgressBar(barraP,st1,label=paste(st1,"/",n.staz))
};close(barraP)

# controlla tu stesso che chiamando direttamente la funzione .Internal la velocita' aumenta di 70 volte
# rispetto al semplice cor(x,y,use="na.or.complete") [l'ultima opzione, FALSE, serve per impostare il methodo di pearson]:
# system.time(for(i in 1:100000).Internal(cor(x,y,5L,FALSE))) #[5L e' l'na.method scelto (il quinto)]
# (la opzione 5L corrsisponde a use="na.or.complete" restituisce NA solo se non c'e' nemmeno una coppia di dati senza NA in tutte e due le serie)

 for(st1 in 1:n.staz)log.cor[st1,st1,]<-1 # imposta ad 1 le correlazioni tra la stessa serie
 
 for(st1 in 2:n.staz){ # dato che la matrice e' simmetrica, calcola i valori simmetrici copiando quelli dell'altra meta' della matrice
	for(st2 in 1:(st1-1)){
		for(mese in 1:12)log.cor[st1,st2,mese]=log.cor[st2,st1,mese]
	}
 }
 
 save.image(paste("C:/nicola/precipitaciones/Local_Regression_Kriging/LRK_v1.RData",sep=""))
 write.table(log.cor,file="C:/nicola/precipitaciones/Local_Regerssion_Kriging/correlaciones_mensuales.txt",row.names=FALSE,col.names=FALSE,quote=FALSE)
} # chiude l'if su correl

################### CARICA CONTORNO PENISOLA IBERICA E PROIETTA LE SERIE PREC IN COORD.GEOGR O UTM30 ##############################################################################3
coordinates(infofile) <- c('LONGITUDE','LATITUDE') # specifica le colonne delle coordinate di infofile
bbox(infofile)  #leggere i valori min e max delle coordinate
#sp::plot(infofile,cex=0.3,col="light blue")
#sp::plot(IpPoly,add=T) # solo per vedere dove sono le stazioni
proj4string(infofile) <- coord.system.geograf # +ellps=clrk66") # specifica il sistema di riferimento delle colonne delle coordinate di infofile (dev'essere con i gradi decimali perche'le due colonne long e lat sono espresse cosi')

if(proyected==TRUE)infofile<-spTransform(infofile, coord.system.proyected)  # proietta le stazioni in UTM30
#summary(my.grid.values) #plot(infofile) # per vedere la forma della griglia proiettata!

# importa il bordo della IP con frontiera tra Spagna e Portogallo:
IpPoly<- readShapePoly(IpPoly.geograf)
proj4string(IpPoly) <- coord.system.geograf 
if(proyected==TRUE)IpPoly<-spTransform(IpPoly, coord.system.proyected) # proietta il perimetro della penisola iberica a UTM30
#sp::plot(IpPoly); summary(IpPoly); IpPoly$bbox

# crea un generico grid a <pixel.size> gradi dec che si sovrapponga a tutta la Penisola Iberica:
if(proyected==FALSE){coord.system<-coord.system.geograf}else{coord.system<-coord.system.proyected}
if(proyected==FALSE){pixel.size<-pixel.size.geograf}else{pixel.size<-pixel.size.proyected*1000} # *1000 per passare da km a metri
if(proyected==FALSE){xmin.box<-xmin.box.geograf}else{xmin.box<-xmin.box.proyected}
if(proyected==FALSE){ymin.box<-ymin.box.geograf}else{ymin.box<-ymin.box.proyected}
if(proyected==FALSE){num.x.pixels<-num.x.pixels.geograf}else{num.x.pixels<-num.x.pixels.proyected}
if(proyected==FALSE){num.y.pixels<-num.y.pixels.geograf}else{num.y.pixels<-num.y.pixels.proyected}
if(proyected==FALSE){resol.unit<-"DecDegr"}else{resol.unit<-"Km"}
gt = GridTopology(cellcentre.offset = c(xmin.box,ymin.box), cellsize = c(pixel.size,pixel.size), cells.dim = c(num.x.pixels,num.y.pixels))
grd = SpatialGrid(gt)
n.pixels<-grd@grid@cells.dim[1]*grd@grid@cells.dim[2] # o equivalentemente:	num.x.pixels * num.y.pixels
proj4string(grd) <- coord.system
#summary(grd);sp::plot(IpPoly);sp::plot(grd,add=T);sp::plot(infofile[2414,],add=T) # visualizza il grid sovrapposto alla IP e la stazione di Zaragoza!

#importa il bordo della sola Spagna (alternativamente si puo' anche importare solo quello in coord.geografiche e poi convertirlo in UTM30 come per IpPoly):
if(proyected==FALSE){SpainPoly<-readShapePoly(SpainPoly.geograf)}else{SpainPoly<-readShapePoly(SpainPoly.proyected)}
#SpainPoly@bbox;summary(SpainPoly);plot(SpainPoly);spplot(SpainPoly)

my.points<-list('sp.points',infofile,pch=1,cex=0.2,col="black")
my.polygon<-list('sp.polygons',IpPoly,fill='transparent',first=F) # first=FALSE gli dice di NON disegnare il poligono per primo # altre opzioni di list: fill=0, lwd=3, lty=2
my.layout<-list(my.polygon)
my.layout2<-list(my.polygon,my.points) 

#importa le province spagnole non proiettate:
#SpainProvPoly <- readShapePoly('C:/my_R_scripts/manuales/Introduction to R/cursoR_AEMET_2010/ejercicios/borders_espana/borders_sin_proyeccion.shp')
#SpainProvPoly <- as(readShapePoly('c:/cursoR/ejercicios/province/pol_prov'), 'SpatialPolygonsDataFrame')
#plot(SpainProvPoly) #disegna il grafico delle province

if(int.method!="OK"){ # importa l'MDE:
	if(proyected==FALSE){mde<-mde.geograf}else{mde<-mde.proyected}
	elevGrid <- readAsciiGrid(mde)
	elevGrid@bbox;summary(elevGrid);image(elevGrid);spplot(elevGrid)

	# verifica che l'mde e i dati si sovrappongano bene alla Spagna (se non va bene cambia i valori di xllcorner e yllcorn):
	#sp::plot(SpainPoly);sp::plot(elevGrid, col='gray',cex=0.4, add=T);plot(infofile, col='red',cex=0.5, add=T)
}

if(regr.prec.vs.alt==TRUE){ ############ REGRESSION PREC VS ALTEZZA ##################################################################

	st.min=100 # numero minimo di stazioni per fare la regressione
	#corr.min=0.5 # soglia minima di corr.mensile per considerare una stazione valida per la interpolazione

	for(mese in 1:12){}
}

if(interpol!="NO"){###################################### MONTHLY PRECIPITATION GRID #############################################################################
	# cerca se ci sono 2 o + serie che hanno le stesse coordinate; in questi casi, le sposta di un metro piu' a nord in modo che si possa fare il kriging:
	# alternativamente, la funzione zerodist(infofile) restituisce il numero di fila delle stazioni con la stessa long e lat
	if(dim(zerodist(infofile))[1]>0)print(paste("***** Trovate",dim(zerodist(infofile))[1],"serie coincidenti che sono state spostate un poco piu' a nord *****"))
	lonlat<-infofile@coords # stringa con la long+lat di ogni stazione # equivalentemente: lonlat<-paste(coordinates(infofile)[,1],coordinates(infofile)[,2])
	nlonlat<-dim(lonlat)[1]
	if(proyected==FALSE){small.shift<-0.00001}else{small.shift<-1}
	#n.coinc<-0
	for(st in 1:nlonlat){
		   ss<-which(lonlat[,1]==lonlat[st,1] & lonlat[,2]==lonlat[st,2]) # vettore con tutte le righe della tabla che hanno la stessa lon e lat della riga staz (dovrebbe esserci 1 sola fila)
		   nss<-length(ss) # se vale 1 vuol dire che va bene
		   if(nss>1){
			#print(paste(st,listaz[st],ss[1],ss[2])) # riga per il debug; normalmente ci sono 2 stazioni nella stessa posizione
			for(k in 2:nss)infofile@coords[ss[k],2]=infofile@coords[ss[k],2]+small.shift*k-1 # aumenta di k centomillesimi di grado o di k metri la latitudine (esclusa la prima stazione del gruppo)
			#n.coinc<-n.coinc+1 #print(n.coinc)
		   }  
	  }
	  
	tot.int<-end.int-start.int+1
	period.int<-start.int:end.int # sostituisce il vecchio period<-yearB:yearE

	# toglie gli anni di dati delle stazioni mensili di prec.fuori dal periodo considerato per fare l'interpolazione:
	dati.int<-subset(dati,dati[[2]]>=start.int & dati[[2]]<=end.int)

	# se stiamo interpolando la climatologia crea prima una matrice con la climatologia, ovvero il valor medio della prec. calcolato su tutti gli anni del periodo impostato e per ogni mese:
	if(interpol=="CLI"){
		promedio<-desv<-matrix(NA,n.staz,12)
		for(st in 1:n.staz){for(mese in int.mesi)promedio[st,mese]=mean(dati.int[((st-1)*tot.int+1):(st*tot.int),2+mese],na.rm=T)[[1]]}
		for(st in 1:n.staz){for(mese in int.mesi)desv[st,mese]=sd(dati.int[((st-1)*tot.int+1):(st*tot.int),2+mese],na.rm=T)[[1]]}
		
		end2.int<-start.int # cosi' elimina il prossimo ciclo for su y
	}else{end2.int<-end.int}

	# interpola per ogni anno (ovvero crea un raster per ogni anno), a meno che non sia impostato interpol="CLI",
	# nel qual caso interpola solo il valore medio su tutto il periodo da start.int a end.int (cioe' la climatologia)
	if(proyected==TRUE)dmax2<-dmax*1000 # *1000 per passare da km a metri
	int.dati<-c()
	for(y in start.int:end2.int){ 
		# carica i dati dei valori mensili di prec.in infofile in base all'anno considerato (o direttamente tutta la climatologia se interpol="CLI"):
		 for(mese in 1:12){
			# nel caso della climatologia inserisci qui la variabile da mappare: la media (promedio[,mese]) o la varianza (desv[,mese]):
			 if(interpol=="CLI"){infofile[[4+mese]]<-promedio[,mese]} else {st<-1:n.staz;infofile[[4+mese]]<-dati.int[((st-1)*tot.int+1)+y-start.int,2+mese]}
			 names(infofile)[4+mese]=nome.mese.short[mese]
		 }

		# crea un grid vuoto (prec.grid) dove mettere i risultati dell'interpolazione e un'altro (void.grid) che rimanga sempre vuoto da usare come plantilla invece di infofile:
		Prec.grid<-void.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,n.pixels)), proj4string = coord.system)
		
		# interpola ogni mese dell'anno (anche se la regressione non si fa su tutti i mesi),
		# mette il risultato in Prec@grid ed arrotonda la precipitazione prevista alla prima cifra decimale per non occupare troppo spazio se poi la si salva su un .txt (tanto l'errore introdotto arrotondando e' trascurabile)::
		formul<-c(Jan~1,Feb~1,Mar~1,Apr~1,May~1,Jun~1,Jul~1,Aug~1,Sep~1,Oct~1,Nov~1,Dec~1)
		infofile.sinNA<-infofile
		for(mese in 1:12){ 
			# occhio che purtroppo la funzione variogram non accetta NA come dato di input, se ti dice "Error: dimensions do not match", c'e' qualche NA.
			# percio'per fare il variogramma gli NA vengono sostituiti con il valore medio mensile per la serie con NA, anche se non e' corretto, ma tanto servono solo per calcolare il variogramma
			# se stiamo calcolando la climatologia invece gli NA non sono mai presenti perche' il promedio e'stato fatto con l'opzione na.rm=T
			ss<-which(is.na(infofile[[4+mese]]))
			if(length(ss)>0){
				for(s in ss)infofile.sinNA[[4+mese]][s]<-mean(dati.int[((s-1)*tot.int+1):(s*tot.int),2+mese],na.rm=T)[[1]] 
			}
			v <- variogram(formul[[mese]], infofile.sinNA, proyected=proyected,cutoff=dmax2)
			#plot(v,type='b') # per vedere i punti del semivariogramma, type=b traccia anche una linea spezzata tra i punti, ma non e' il fit
			#v.fit <- fit.variogram(v, model=vgm(psill=8000, model='Gau', range=200000, nugget=500)) # calcola automaticamente tutti i parametri della curva di fit, basta dargli dei valori iniziali approssimativi!!!!!
			temp.nugget<-v$gamma[1] 		# valore inziale del nugget per fare una prova, dopodiche l'algoritmo di fit.variogram aggiusta i valori
			temp.sill<-last(v$gamma)	# come valori iniziali ho messo quelli che si possono ricavare 'ad occhio' dal variogramma sperimentale v
			temp.range<-last(v$dist)
			v.fit <- fit.variogram(v, model=vgm(psill=temp.sill-temp.nugget, model='Sph', range=temp.range, nugget=temp.nugget),fit.ranges=FALSE) # ho dovuto mettere fit.ranges=FALSE perche' a volte fitta dei range negativi che danno errore fermando i calcoli
			print(plot(v,v.fit)) # per vedere il semivariogramma + la curva di fit

			#v.fit #per vedere i parametri risultato del fit #plot(v,v.fit) # per vedere il semivariogramma + la curva di fit #b <- mean(DistData[[i]][[j+1]]) # solo per il simple kriging
			print(paste("Anno:",y,"; Mese:",mese)) # cosi' se avvisa che il variogram e' un singular model sai a che mese e anno si riferisce
			#Prec.grid@data[[mese]]<-round(krige(formula=formul[[mese]], locations=infofile.sinNA, newdata=grd, model=v.fit,nmax=int.nmax)@data$var1.pred,1) # se desse problemi a fare il kriging prova a vedere se dipende da una cattiva curva del fit, prova magari a impostare un range del fit piu' corto.
			if(loocv==FALSE){
				# problema: se ci sono NA in location non puo'interpolare. GLi NA ci possono essere solo in newdata. Percio'dovresti togliere
				# da infofile le serie con NA, ma dato che per mesi diversi le serie con NA di solito cambiano, dovresti creare un infofile diverso
				# per ogni mese! Per il momento ho sostituito la posto di infofile infofile.sinNA che al posto degli NA ha il promedio dei valori
				# della serie, ma non ? una soluzione corretta!
				Prec.grid@data[[nome.mese.short[mese]]]<-round(krige(formula=formul[[mese]], locations=infofile.sinNA, newdata=grd, model=v.fit,nmax=int.nmax)@data$var1.pred,1) # come prima ma permette di considerare anche input con osservatori senza dati (NA) perche' li esclude dall'interpolazione!!! (con na.omit)
			} else { # fa la leave-one-out cross-validation (loocv):
				Prec.loocv<-infofile;Prec.loocv@data[[nome.mese.short[mese]]]<-NA
				for(st in 1:n.staz){
					temp<-krige(formula=formul[[mese]], locations=infofile,na.action=na.omit, newdata=infofile[st,], model=v.fit,nmax=int.nmax) #temp<-krige.cv(formula=formul[[mese]], locations=infofile, model=v.fit,nmax=int.nmax) # si puo' usare anche anche krige.cv ma 1) e'piu'lenta di un 20% e 2) non si puo' inserire l'opzione per i missing data
					#print(st)
					Prec.loocv@data[[nome.mese.short[mese]]][st]<-round(temp@data$var1.pred,1)  # su var1.var c'e' la varianza dell'errore, ovvero il RMSE al quadrato dei residuali
				} # chiude il for su n.staz			
			} # chiude l'if sul loocv
		}
		
		#if(loocv==FALSE)names(Prec.grid@data)<-nome.mese.short

		# seleziona i pixel di mare con overlay e li mette a NA in modo che non li disegni nella mappa finale:
		sea.pixels<-which(is.na(overlay(grd,IpPoly))==T)
		land.pixels<-(1:n.pixels)[-sea.pixels]
		for(mese in 1:12)Prec.grid@data[[nome.mese.short[mese]]][sea.pixels]=NA

		# matrice della forma num.pixel/anno/gen/feb/.../dic che memorizza i dati di prec per ogni singolo anno della interpolazione (o solo la climatologia):
		int.dati<-rbind(int.dati,cbind(1:n.pixels,y,Prec.grid@data)) # int.dati e' la unione di tanti colonne di dati di Prec.grid, un PRec.grid per ogni anno, cioe' e' del tipo pixel/anno/12 mesi
		if(interpol=="SI")my.grid.name=paste("Monthly Precipitation Grid for year ",y,sep="")
		if(interpol=="CLI")my.grid.name=paste("Monthly Precipitation Climatology for period ",start.int,"-",end.int,sep="")
		
		# visualizza e/o salva in un .pdf le 12 mappe mensili appena interpolate:
		if (start.int-end2.int>0){second.part=paste("-",end.int,".pdf",sep="")} else { second.part=".pdf"}
		my.prec.levels<- c(seq(0,50,1),seq(52.5,150,2.5),seq(155,200,5),seq(210,290,20),300)
		my.prec.levels.in.leyend<-c(0,25,50,75,100,150,200,300,400)
		my.prec.levels2<- c(0,1,5,10,20,30,50,70,100,150,200,300,500) # leyenda uguale a quella di Ricardo
		my.prec.levels3<- c(-100,0,1000) # per vedere se ci sono pixel interpolati minori di 0
		my.period<-c(12,1,2,3,4,5,6,7,8,9,10,11) # seleziona i mesi da mappare
		my.names<-nome.mese.esp[my.period]
		Prec.grid2<-Prec.grid
		for(mese in 1:12)Prec.grid2@data[nome.mese.short[mese]][which(Prec.grid@data[nome.mese.short[mese]]>300),]<-300
		my.map<-spplot(Prec.grid2,zcol=nome.mese.short[my.period],at=my.prec.levels,col.regions=rev(jet.colors(10000)),main=my.grid.name,par.settings = standard.theme(color = FALSE), sp.layout=my.layout,as.table=TRUE,names.attr=my.names,colorkey=list(space="right",width=0.5,height=1,labels=list(at=my.prec.levels.in.leyend)))
		
		# print(my.map) # per visualizzare la mappa interpolata solo sullo schermo o (fila sotto) per inviarla a un immagine su disco:
		# jpeg("C:/nicola/precipitaciones/weather_types/mapas/6) composiciones_EMULATE_y_IP02/Climatology_Mopredas_1950-2003_same_coord_system_as_Ip02.jpg",width=590,height=616,quality=100);print(my.map);dev.off() # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
		
		### BOXPLOT della climatologia mensile:
		# Prec.grid2@data<-Prec.grid2@data[,c(2:13)] # toglie la prima colonna senza dati
		# #ss<-which(is.na(Prec.grid2@data[[1]])) # toglie gli NA
		# #Prec.grid2@data<-Prec.grid2@data[-ss,]
		# fixInNamespace(boxplot.default, "graphics") # dopodiche devi editare la riga con boxplot.stats sostituendola con myboxplot.stats. In questo modo visualizza come estremi i valori dei percentili 5 e 95 invece di 1.5*IQR. Se vuoi visualizzare solo i valori minimi e massimi metti range=0 nella funzione boxplot
		# boxplot(Prec.grid2@data,boxwex=.5,col="cyan3",outline=F,ylab="mm") # boxwex e?la larghezza di ogni box, outline per togliere i punti outliers.
		# #means<-colMeans(Prec.grid2@data) # per disegnare anche la media
		# #points(means,col="red",pch="+",cex=1)
		
		### zoom sulle precipitazioni alte:
		# my.prec.levels<- c(seq(80,300,10),500)
		# my.prec.levels.in.leyend<-c(80,100,150,200,300,500)
		# my.map<-spplot(Prec.grid,zcol=nome.mese.short,at=my.prec.levels,col.regions=rev(jet.colors(10000)),main=my.grid.name,
					# sp.layout=my.layout,as.table=T,colorkey=list(space="right",width=0.5,height=1,labels=list(at=my.prec.levels.in.leyend)))
		# print(my.map) # per visualizzarlo solo sullo schermo
		# jpeg("C:/nicola/precipitaciones/weather_types/mapas/6) composiciones_EMULATE_y_IP02/Climatology_Mopredas_1950-2003_scale2.jpg",width=590,height=616,quality=100);print(my.map);dev.off() # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.

		## salva un .pdf con la mappa della distribuzione spaziale dei punti delle stazioni colorati in base al valore di prec.assunto:
		# my.points.name="Monthly Rainfall Distribution" # parametri grafici
		#pdf(paste(dir_root,"/Monthly Precipitation Stations ",start.int,second.part,sep=""))
		#print(spplot(infofile,nome.mese.short[1],key.space = "right",cuts=my.prec.levels3,col.regions=rev(jet.colors2(1000)),main=my.points.name,sp.layout=my.layout,cex=0.4,as.table=T,fill=T))
		#dev.off() # e per sovrapporre i punti colorati al grid come si fa????
		 
		## esporta ogni mappa mensile in un file ASCII con valore di manca-dato uguale a -99 invece di -9999 e 1 sola cifra decimale per non occupare tanto spazio:
		#if(interpol=="SI")for(mese in int.mesi)writeAsciiGrid(Prec.grid,paste(dir_root_kriging,"/",nome.mese[mese]," Prec.Grid ",pixel.size," ",resol.unit," ",y,".txt",sep=""),attr=nome.mese.short[mese],na.value=-99)
		#if(interpol=="CLI")for(mese in int.mesi)writeAsciiGrid(Prec.grid,paste(dir_root_kriging,"/",nome.mese[mese]," Prec.Climatology ",pixel.size," ",resol.unit," ",start.int,"-",end.int,".txt",sep=""),attr=nome.mese.short[mese],na.value=-99)
	} # chiude il for su y

	if(loocv==TRUE){ # se stiamo facendo la cross-validation della climatologia calcola i residuali e li visualizza, poi il MAE, il RMSE, il CV(MAE) e il CV(RMSE) per tutte le staz.
		prec.residual<-array(NA,c(n.staz,12),dimnames<-list(1:n.staz,nome.mese))
		prec.residual<-Prec.oocv
		my.main<-"Kriging Residuals"; # ovvero la climatologia dei WTs, CON la costante
		my.cuts<-c(seq(0,300,20),350,400,500)
		my.colors<-jet.colors8
		prec.residuals.mappa<-infofile;for(mese in 1:12)prec.residuals.mappa@data[[nome.mese.short[mese]]]<-NA
		for(mese in 1:12)prec.residuals.mappa@data[[nome.mese.short[mese]]]<-as.vector(t(prec.residual[,mese])) # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)

		my.map<-spplot(,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
			cuts=my.cuts,col.regions=rev(jet.colors(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,names.attr=nome.mese[int.mesi],legendEntries=my.labels)
		my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
		plot(my.map)
	} # chiude l'if su loocv

	# riordina la matrice int.dati per la prima e seconda colonna (pixel e anno) in modo che sia nello stesso ordine della matrice dati:
	int.dati<-int.dati[order(int.dati[,1],int.dati[,2]),]

	## se vuoi utilizzare le interpolazioni annuali come input di my R scripts\Remo models\2) analysis_vX.r 
	## devi cambiare il formato, da: year/mes in orizz.	a: year/month/lat/long in orizzontale. Per farlo puoi usare il package "Reshape":
	# if(interpol=="SI"){
		# #if(proyected==FALSE){mod.size<-1}else{mod.size<-1000} # *1000 per passare da km a metri
		# #x.values<-sort(unique(SpatialPoints(grd)@coords[,1])) # elenco valori possibili di long dei centri dei pixel del grid
		# #y.values<-sort(unique(SpatialPoints(grd)@coords[,2])) # elenco valori possibili di latitud dei centri dei pixel del grid
		# xy.values<-SpatialPoints(grd)@coords # estrae le coordinate dei centri di ogni pixel del grid nello stesso ordine usato dal grid grd
		# int.dati<-int.dati[order(int.dati[,2]),] # riordina int.dati in modo che sia ordinata per anni invece che per pixel
		# grid.clim.for.cfr.Ensemble<-cbind(xy.values,int.dati[,2:14])
		# names(grid.clim.for.cfr.Ensemble)[1:3]<-c("LON","LAT","YEAR")
		# library(reshape);library(reshape2)
		# temp<-melt.data.frame(grid.clim.for.cfr.Ensemble,id=c("YEAR","LON","LAT"),variable_name="MONTH")
		# temp$MONTH<-as.numeric(match(temp$MONTH,nome.mese.short)) # sostituisci la colonna con i mesi scritti in lettere con i mesi scritti in numeri per avere la stessa notazione usata nel confronto con i modelli Ensemble
		# temp2<-dcast(temp,YEAR+MONTH+LAT~LON)
		# grid.clim.for.cfr.Ensemble<-temp2;rm(temp);rm(temp2)
		# #write.table(grid.clim.for.cfr.Ensemble,"C:/nicola/precipitaciones/Local_Regression_Kriging/precipitation 1961-2000_ordinary_kriging.txt",quote=FALSE,row.names=FALSE,col.names=FALSE)
		# write.table(grid.clim.for.cfr.Ensemble,"C:/nicola/precipitaciones/Local_Regression_Kriging/precipitation 1950-2003_ordinary_kriging.txt",quote=FALSE,row.names=FALSE,col.names=FALSE)
	# } # chiude l'if su interpol=="SI"

	#save.image("C:/nicola/precipitaciones/kriging_mensuales_Iberia/R_session_v2_Monthly_prec_Mopredas_con_coord_system_Ip02_o_sea_res_0.20.RData")
	#save.image("C:/nicola/precipitaciones/Local_Regression_Kriging/LRK_v3_interpolacion_con_NA_y_loocv.RData")

} # chiude l'if su interpol!="NO"

 ################################## PREPARA I DATI PRIMA DI APPLICARE IL MODELLO DI REGRESSIONE E/O LA PCA ###############################################################
 tot.regr<-end.regr-start.regr+1 #numero di anni di durata della regressione

if(interpol=="NO"){
	 # toglie gli anni di dati delle stazioni mensili di prec.prima dell'inizio della regressione e dopo la fine della regressione:
	 # (il numero delle serie non cambia anche se ci possono essere serie senza dati nel periodo scelto)
	dati.regr<-subset(dati,dati[[2]]>=start.regr & dati[[2]]<=end.regr)
	n.staz.regr<-n.staz
	matrix.regr<-cbind(rep(1:n.staz,each=tot.regr),as.matrix(dati.regr[,2:14])) #matrix.regr e' come dati.regr ma in forma matriciale e con i numeri delle serie invece dei codici sulla prima colonna
} else {
	# se stiamo interpolando, i dati e le serie per la regressione non sono ricavati a partire dal dataframe dati
	# ma a partire dai pixel dell'interpolazione (che sono gia' stati calcolati escludendo il periodo prima dell'inizio della regress e dopo la sua fine):
	n.staz.regr<-n.pixels
	# se vogliamo usare i valori mensili di Ip02 dobbiamo caricarli ora:
	# int.dati<-read.table("C:/nicola/precipitaciones/weather_types/Ip02/Database_IBERIA_0.2/Iberia_0,2_en_mensuales.txt")
	matrix.regr<-int.dati
}

# toglie gli anni di dati dei WT mensili prima dell'inizio della regressione e dopo la fine della regressione, cosi' come ha fatto con i dati di prec:
monthlyWT.regr<-list()
for(cla in cla.rif)monthlyWT.regr[[cla]]<-subset(monthlyWT[[cla]],monthlyWT[[cla]][,1]>=start.regr & monthlyWT[[cla]][,1]<=end.regr)

# toglie gli anni di dati dei WT mensili prima dell'inizio della ricostruzione e dopo la fine della ricostruzione, cosi' come ha fatto con i dati di prec:
monthlyWT.recons<-list()
for(cla in cla.rif)monthlyWT.recons[[cla]]<-subset(monthlyWT[[cla]],monthlyWT[[cla]][,1]>=start.recons & monthlyWT[[cla]][,1]<=end.recons)

################################## PCA DEI WTS MENSILI ###########################################################################################
# per ogni classificazione e per ogni mese fa la PCA dei WTs su TUTTO il periodo ricostruito (incluso quello di misura della bonta'della ricostr.)

if(PCRA==TRUE){
	PCA.recons<-PCA.regr<-list()

	for(cla in cla.rif){
		PCA.recons[[cla]]<-PCA.regr[[cla]]<-list()

		for(mese in 1:12){
			temp<-subset(monthlyWT.recons[[cla]],monthlyWT.recons[[cla]][,2]==mese)

			col.zeri<-c() # in ogni caso bisogna togliere tutte le colonne con WT=0
			i=1;for(w in 1:nWT[cla]){if(sum(temp[,2+w])==0){col.zeri[i]=2+w;i=i+1}}

			if(stand==TRUE){
				col.mean<-apply(temp,2,mean)
				col.std<-apply(temp,2,sd)
				temp.stand<-temp
				for(w in 1:nWT[cla])temp.stand[,2+w]<-(temp[,2+w]-col.mean[2+w])/col.std[2+w]
				temp<-temp.stand
			}

			WTs<-temp[,-c(1,2,col.zeri)] # -c(1,2,col.zeri) toglie le colonne con gli anni, con i mesi e con tutti i num.uguali a zero

			# fai la S-mode PCA dei 26 tipi di tempo di quella classificazione per il periodo di calibrazione: (cioe', riduce le colonne con i tipi di tempo)
			PCA.recons[[cla]][[mese]]<-princomp(WTs,cor=correl) #str(PCA.recons[[cla]][[mese]]);summary(PCA.recons[[cla]][[mese]]);plot(PCA.recons[[cla]][[mese]])

			# nota che puoi ottenere gli scores anche con:
			# WTs %*% loadings(PCA.recons[[cla]][[mese]]) e i loadings con eigen(cor(WTs))$vectors (perche' sono gli autovettori della matrice di correlazione)

			if(rotation==TRUE){
				loadings.rot<-varimax(loadings(PCA.recons[[cla]][[mese]]))$loadings # calcola i nuovi loadings ruotati
				PCA.recons[[cla]][[mese]]$scores<-WTs %*% loadings.rot # calcola i nuovi scores ruotati
			}

			PCA.regr[[cla]][[mese]]<-PCA.recons[[cla]][[mese]]
			PCA.regr[[cla]][[mese]]$scores<-PCA.recons[[cla]][[mese]]$scores[(start.regr-start.recons+1):(end.regr-start.recons+1),]
		 
		} # chiude il for sui mesi
	} # chiude il for su cla
} # chiude l'if

############################################# STEPWISE REGRESSION PREC vs WTs ######################################################################
mod<-c();if(intercept==FALSE){mod=0} else {mod=1}
regr.best<-array(NA,c(n.classi,n.staz.regr,12)) # vale 1 se il miglior metodo per quella classificazione, stazione e mese e' il forward, 2 se e' il backward
r2.best<-array(NA,c(n.classi,n.staz.regr,12)) # r2 per quella classificazione, stazione e mese con il migliore dei due metodi
pred.forw<-pred.back<-array(NA,c(max.nWT,n.classi,n.staz.regr,12))  # indica quali sono i WT usati dalla regressione migliore forward e backward
n.pred.forw<-array(NA,c(n.classi,n.staz.regr,12)) # numero di predittori della migliore regressione forward stepwise
coeff.best<-array(NA,c(max.nWT+mod,n.classi,n.staz.regr,12)) # terra'i coefficienti dei predittori WT della regressione migliore e della intercetta (se c'e')
coeff.forw.all<-array(NA,c(num.max.pred,num.max.pred+mod,n.classi,n.staz.regr,12)) # se stepwise=FALSE, per ogni regressione con X<=num.max.pred predittori, memorizza i coefficienti della regressione forward (eventuale intercetta per prima)
media.prec.obs<-array(NA,c(n.staz.regr,12)) # indica il valor medio della precip.osservata su tutti gli anni della regressione (per poter calcolare piu' avanti la dev.snd normalizzata)
years.missing<-array(NA,c(n.staz.regr,12)) # memorizza per ogni stazione e mese il numero di anni mancanti su cui la regressione non si e' potuta fare
years.missing.list<-array(NA,c(n.staz.regr,12,tot.regr)) # memorizza QUALI sono gli anni mancanti per ogni regressione
# purtroppo il metodo della regr.lin stepwise implementato con la funzione step e' molto lento e a volte tutti i coeff.sono negativi, percio' cambio:
# uso sempre il metodo stepwise, ma scrivendolo a mano a partire dalla funzione 'nnls' che minimizza |Ax-b| per x>0 vettore in modo che i coeff.
# della regressione non siano mai negativi (nemmeno la intercetta):

# if(interpol!="NO")land.pixels<-land.pixels[-which(land.pixels==477)] # se stiamo usando il database Ip02 devo togliere questo pixel perche'e' di mare ma viene scambiato come pixel di terra quando lo si confronta con il poligono della IP

barraP<-winProgressBar("Stepwise Regression","Please wait...",0,n.classi*12,0)
for(mese in int.mesi){
	for(cla in cla.rif){
		# crea una matrice 'A' solo con i WTs o i PCs della classificazione e del mese scelto:
		if(PCRA==TRUE){A<-PCA.regr[[cla]][[mese]]$scores} else {A<-subset(monthlyWT.regr[[cla]],monthlyWT.regr[[cla]][,2]==mese,select=3:(2+nWT[cla]))}
		# aggiunge una colonna di 1 a sinistra di A corrispondente alla intercetta (termine noto):
		if(intercept==T)A<-cbind(1,A) 

		 # cicla sulla serie da analizzare all'interno di n.staz.regr:
		series<-1:n.staz.regr
		if(interpol!="NO")series<-land.pixels # praticamente series diventano solo i pixel di terra

		# soprattutto d'estate puo'accadere di trovare WT con frequenza nulla per tutto il periodo di regressione,
		# percio'bisogna eliminare le colonne di A corrispondenti a questi WT:
		# (per esempio per il database EMULATE a luglio bisogna togliere i WTs num.4,13,14 e 23 che corrisp.ai tipi S, C.S, C.SW e A.SW, e ad agosto i num.14 e 23)
		dev.stand<-apply(A,2,sd) # dev.stnd. di ogni colonna di A inclusa la eventuale intercetta per la quale la dev.stnd e' zero.
		if(mod==1)dev.stand<-dev.stand[-1] # toglie l'eventuale primo elemento inutile dato dall'intercetta
		WTs.para.tirar<-c();if(min(dev.stand)<0.00001)WTs.para.tirar<-which(dev.stand<0.00001)

		for(st in series){
			# stat=listaz[st] 
			#b<-subset(matrix.regr,matrix.regr[[1]]==st,select=2+mese)[[1]]  # colonna prec. (seleziona solo le file di prec della serie e del mese che ci interessa):
			b<-as.numeric(matrix.regr[((st-1)*tot.regr+1):(st*tot.regr),nome.mese.short[mese]]) # piu' efficiente del subset, non usa stat e lavora con matrici invece di dataframe sostituendo alla colonna del codice una colonna con il numero della serie o del pixel (occhio che non funziona con il grid Ip02, bospgna usare la rigas sopra invece)
			# [nota che b coincide con la variabile prec.obs.regr introdotta piu' in basso per validare il modello]

			years.NA<-which(is.na(b)) # individua i mesi senza un valore di precipitazione [years.NA e' uguale alla variabile y.regr.NA che si calcola quando si fa la validazione del modello]
			years.missing[st,mese]=length(years.NA)
			years.missing.list[st,mese,]<-c(years.NA,rep(NA,tot.regr-years.missing[st,mese])) 
			
			#if(length(!is.na(b))==0){stop("b non ha dati osservati di prec.")}

			media.prec.obs[st,mese]<-mean(b,na.rm=TRUE) # calcola la prec.media obs. eliminando gli anni con NA
			tot.regr2<-tot.regr-years.missing[st,mese] # anni effettivi usati nella regressione

			if(PCRA==TRUE){max.interv<-dim(PCA.recons[[cla]][[mese]]$scores)[2]} else {max.interv<-nWT[cla]} # se stiamo facendo la PCRA dobbiamo considerare che le colonne possono essere di meno di nWT[cla] perche' abbiamo dovuto togliere le colonne con solo zeri
			interv<-1:max.interv # all'inizio tutti i WT sono disponibili per la regressione stepwise; poi diminuiscono togliendo quelli gia' utilizzati
			if(length(WTs.para.tirar)>0)interv<-interv[-WTs.para.tirar]
			
			# se per caso togliendo alcune righe di A senza dati di prec.oss si sono formate colonne con dati costanti o quasi (intercetta a parte) bisogna toglierle dall'elenco dei possibili predittori altrimenti si confondono con la intercetta e a volte i coeff.di regressione schizzano a 1000000 o piu'!!!:
			if(years.missing[st,mese]!=0){
				deviaz.stand<-apply(A[-years.NA,],2,sd)[(1+mod):(max.interv+mod)] # dev.stnd. di ogni colonna di A senza le righe senza pioggia oss.
				if(min(deviaz.stand)<0.00001)interv<-interv[-which(deviaz.stand<0.00001)]
			}
					
			regr<-list();r.squared<-adj.r.squared<-adj.r.squared.best<-p.best<-c()

			for(p in interv){ # esegue una alla volta tutte le regr.lineari con una sola variabile (+ l'intecetta se c'e'), ciclando tra tutti i WTs o PCs:				
				A.1pred<-cbind(A[,mod],A[,mod+p]) #  estrae dalla matrice A solo le colonne con i predittori, piu' l'eventuale colonna dell'intercetta
				# uso la funzione lm.fit.fast per velocizzare i calcoli di 100 volte!!! Altrimenti avrei dovuto usare la vecchia funzione lm(b~.-1,data=as.data.frame(A.1pred))} # il -1 serve per togliere l'intercetta dall'algoritmo lm, perche e' gia' inclusa dentro A.1pred. Nota che si deve trasformare A in matrix perche' in questo caso A e' formata da un vettore, e i vettori non hanno l'attributo ncol che serve dentro la funzione nnls 
				if(years.missing[st,mese]==0){
					if(negative==FALSE){regr[[p]]<-nnls(as.matrix(A.1pred),b)} else {regr[[p]]<-lm.fit.fast2(A.1pred,b)} # [occhio che la funzione lm.fit e lm.fit.fast
																											# non accettano anni mancanti, mentre la funzione nnls si]
				} else { # se ci sono anni mancanti devo toglierli perche' la funzione lm.fit.fast non accetta anni mancanti (mentre la funzione nnls si):
					if(negative==FALSE){regr[[p]]<-nnls(as.matrix(A.1pred[-years.NA,]),b[-years.NA])} else {regr[[p]]<-lm.fit.fast2(A.1pred[-years.NA,],b[-years.NA])}
					pr.pred<-regr[[p]]$fitted 
					for(i in 1:years.missing[st,mese])pr.pred<-append(pr.pred,NA,after=years.NA[i]-1) # aggiunge al vettore di prec.pred gli anni tolti perche' con prec.oss.mancante (mettendo come valore la NA); in questo modo il vettore con la prec.pred ha tanti elementi quanto gli anni su tutto il periodo di regressione
					regr[[p]]$fitted<-NULL;regr[[p]]$fitted<-pr.pred
				}
				
				if(jacknife.full==TRUE){
					prec.pred.jack<-rep(NA,tot.regr) # vettore che conterra' la prec.calcolata nel periodo di regressione con il jackknife
					# cicla su tutti gli anni di regressione, compresi quelli con prec.oss = NA per calcolare la prec.prevista con il jackknife:
					for(y in 1:tot.regr){ 
						y.regr.buttare<-c(years.NA,y) # fila corrispondenti ad anni ove la prec.oss vale NA e all'anno y da evaluare (come minimo ce n'e' sempre almeno uno, y, quindi puoi scrivere direttamente la linea di codice seguente:)
						if(negative==FALSE){regr.jack<-nnls(as.matrix(A.1pred[-y.regr.buttare,]),b[-y.regr.buttare])} else {regr.jack<-lm.fit.fast2(A.1pred[-y.regr.buttare,],b[-y.regr.buttare])}
						prec.pred.jack[y]<-max(0,A.1pred[y,] %*% regr.jack[[1]]) # calcola la prec.prevista per l'anno y sulla base dei coeff.appena calcolati per il periodo restante
					} # chiude il for su y
					regr[[p]]$fitted<-NULL;regr[[p]]$fitted<-prec.pred.jack # sostituisce invece della prec.predetta normale quella predetta con il jacknife per tutto il periodo della regressione (anche gli anni senza prec.oss)
				}# chiude l'if sul jacknife
				
				n.pred<-1+mod  # numero di predittori (includendo l'intercetta se intercept=T!)
				if(min.rmse==TRUE){
					r.squared[p]<-((sum((regr[[p]]$fitted-b)^2,na.rm=TRUE))/(tot.regr2-n.pred))^0.5 # calcola l'rmse 
					adj.r.squared[p]<-(-r.squared[p]) # ribalta il valore del rmse perche' cosi'poi quando prendiamo il massimo in realta' prendiamo il valore minimo, che e' quello che ci interessa			
				} else if(min.cv==TRUE){
					r.squared[p]<-((sum((regr[[p]]$fitted-b)^2,na.rm=TRUE))/(tot.regr2-n.pred))^0.5/media.prec.obs[st,mese] # calcola il CV [la somma dei quadrati non basta perche' poi sara'necessario aggiungere a questo valore lo step.min per vedere se fermare la regressione]
					adj.r.squared[p]<-(-r.squared[p]) # ribalta il valore di r.squared ovvero del CV perche' cosi'poi quando prendiamo il massimo in realta' prendiamo il valore minimo, che e' quello che ci interessa			
				} else {
					r.squared[p]<-cor(b,regr[[p]]$fitted,use="pairwise.complete.obs")^2 # calcola l'r2 multiplo come quadrato della correlazione tra i valori di prec.osservati e quelli predetti dalla regressione; occhio che quando la correlazione e' zero invece di mettere 0 mette NA
					if(is.na(r.squared[p]))r.squared[p]=0 # vuole dire che i coeff.dei predittori sono tutti 0 tranne quello dell'intercetta
					adj.r.squared[p]<-r.squared[p]-(1-r.squared[p])*n.pred/(tot.regr2-n.pred)
				} # chiude l'else sul tipo di stepwise, se basato sul r2 o sul CV
			} # chiude il for su p

			adj.r.squared.best[1]<-max(adj.r.squared,na.rm=T)
			p.best[1]<-min(which(adj.r.squared==adj.r.squared.best[1]))
			coeff.forw.all[1,,cla,st,mese]<-c(regr[[p.best]][[1]],rep(NA,num.max.pred+mod-length(regr[[p.best]][[1]]))) # coefficienti della regress.fatta con un solo predittore (quindi sono solo 2 in tutto, un coeff.per l'intercetta e uno per il predittore)
			
			# controlla se il modello a 1 predittore e' migliore (cioe' ha un MSE piu' basso) di quello utilizzando la prec.osservata media come predittore!
			keepgoing="yes"
			if(sum((media.prec.obs[st,mese]-b)^2,na.rm=T)<=sum((regr[[p.best]]$fitted-b)^2,na.rm=T)){
				 keepgoing="no"
				 coeff.forw.all[1,,cla,st,mese]<-c(regr[[p.best]][[1]][1],rep(NA,num.max.pred+mod-1))
				 pred.forw[,cla,st,mese]=rep(NA,max.nWT) # dato che non si e' trovato nessun predittore valido
				 n.pred.forw[cla,st,mese]<-0 # dato che non si e' trovato nessun predittore valido
			 }

			if(keepgoing=="yes"){ # continua solo se l'MSE con il primo predittore trovato e' migliore del MSE con il solo valor medio della prec.osservata
				# fissa il WT con l'R2 adjusted piu'alto trovato ed esegue tutte le regr.lineari con due predittori: il WT selezionato ed un altro WT che cicla:
				# interv<-interv[-p.best[1]]
				n.pred=1+mod # numero di predittori (includendo l'intercetta se intercept=T!) [gia'impostato ma lo ripeto per chiarezza]
				interv<-interv[-which(interv==p.best[1])]
				regr<-list();r.squared<-adj.r.squared<-c()
				for(p in interv){
					if(abs(cor(A[,mod+p.best[1]],A[,mod+p]))>max.autocorrelation){
						adj.r.squared[p]=-100000	# esclude questo tipo di tempo dalla lista dei possibili predittori, se e' altamente collelato con il precedente
					} else {
						A.2pred<-cbind(A[,mod],A[,mod+p.best[1]],A[,mod+p])
						if(years.missing[st,mese]==0){
							if(negative==FALSE){regr[[p]]<-nnls(as.matrix(A.2pred),b)} else {regr[[p]]<-lm.fit.fast2(A.2pred,b)} # [occhio che la funzione lm.fit non accetta anni mancanti, mentre la funzione nnls si]:
						} else { # se ci sono anni mancanti devo toglierli perche' la funzione lm.fit non accetta anni mancanti (mentre la funzione nnls si):
							if(negative==FALSE){regr[[p]]<-nnls(as.matrix(A.2pred[-years.NA,]),b[-years.NA])} else {regr[[p]]<-lm.fit.fast2(A.2pred[-years.NA,],b[-years.NA])}
							pr.pred<-regr[[p]]$fitted 
							for(i in 1:years.missing[st,mese])pr.pred<-append(pr.pred,NA,after=years.NA[i]-1) # aggiunge al vettore di prec.pred gli anni tolti perche' con prec.oss.mancante (mettendo come valore la NA); in questo modo il vettore con la prec.pred ha tanti elementi quanto gli anni su tutto il periodo di regressione
							regr[[p]]$fitted<-NULL;regr[[p]]$fitted<-pr.pred
						}
						
						if(jacknife.full==TRUE){
							prec.pred.jack<-rep(NA,tot.regr) # vettore che conterra' la prec.calcolata nel periodo di regressione con il jackknife
							# cicla su tutti gli anni di regressione, compresi quelli con prec.oss = NA per calcolare la prec.prevista con il jackknife:
							for(y in 1:tot.regr){ 
								y.regr.buttare<-c(years.NA,y) # fila corrispondenti ad anni ove la prec.oss vale NA e all'anno y da evaluare (come minimo ce n'e' sempre almeno uno, y, quindi puoi scrivere direttamente la linea di codice seguente:)
								if(negative==FALSE){regr.jack<-nnls(as.matrix(A.2pred[-y.regr.buttare,]),b[-y.regr.buttare])} else {regr.jack<-lm.fit.fast2(A.2pred[-y.regr.buttare,],b[-y.regr.buttare])}
								prec.pred.jack[y]<-max(0,A.2pred[y,] %*% regr.jack[[1]]) # calcola la prec.prevista per l'anno y sulla base dei coeff.appena calcolati per il periodo restante
							} # chiude il for su y
							regr[[p]]$fitted<-NULL;regr[[p]]$fitted<-prec.pred.jack # sostituisce invece della prec.predetta normale quella predetta con il jacknife per tutto il periodo della regressione (anche gli anni senza prec.oss)
						}# chiude l'if sul jacknife
						
						n.pred<-2+mod	 # numero di predittori + intercetta
						if(min.rmse==TRUE){
							r.squared[p]<-((sum((regr[[p]]$fitted-b)^2,na.rm=TRUE))/(tot.regr2-n.pred))^0.5 # calcola l'rmse
							adj.r.squared[p]<-(-r.squared[p]) # ribalta il valore di r.squared ovvero del rmse perche' cosi'poi quando prendiamo il massimo in realta' prendiamo il valore minimo, che e' quello che ci interessa								
						} else if(min.cv==TRUE){
							r.squared[p]<-((sum((regr[[p]]$fitted-b)^2,na.rm=TRUE))/(tot.regr2-n.pred))^0.5/media.prec.obs[st,mese] # calcola il CV
							adj.r.squared[p]<-(-r.squared[p]) # ribalta il valore di r.squared ovvero del CV perche' cosi'poi quando prendiamo il massimo in realta' prendiamo il valore minimo, che e' quello che ci interessa			
						} else {
							r.squared[p]<-cor(b,regr[[p]]$fitted,use="pairwise.complete.obs")^2 # calcola l'r2 multiplo come quadrato della correlazione tra i valori di prec.osservati e quelli predetti dalla regressione; occhio che quando la correlazione e' zero invece di mettere 0 mette NA
							if(is.na(r.squared[p]))r.squared[p]=0 # vuole dire che i coeff.dei predittori sono tutti 0 tranne quello dell'intercetta
							adj.r.squared[p]<-r.squared[p]-(1-r.squared[p])*n.pred/(tot.regr2-n.pred)					
						} # chiude l'else sul tipo di stepwise, se basato sul r2 o sul CV					
					} # chiude l'else sulla autocorrelazione tra predittori
				} # chiude il for su p

				adj.r.squared.best[2]<-max(adj.r.squared,na.rm=T)
				p.best[2]<-min(which(adj.r.squared==adj.r.squared.best[2]))
				coeff.forw.all[2,,cla,st,mese]<-c(regr[[p.best[2]]][[1]],rep(NA,num.max.pred+mod-length(regr[[p.best[2]]][[1]])))  

				if(stepwise==TRUE){change1=0} else {change1=100} # per attivare la 2nda condizione del while INVECE della prima se si vuole fermarsi esattamente a
																 # tot 	predittori
				if(min.rmse==TRUE){
					step.min=step.min.rmse
				} else if(min.cv==TRUE){
					step.min=step.min.CV
				} else {
					step.min=step.min.r2
				}
				
				# controlla se il miglior R2 adjusted (o il CV) trovato con 2 predittori e' > del miglior R2 adjusted con un solo predittore; se si, continua ad aggiungere
				# un predittore nuovo alla volta, finche l'R2 adjusted non aumenta piu'; se no, non entra nel while e passa a fare la regressione finale con 1 solo predittore
				regr<-list()
				steps=2 # sta ancora usando 2 predittori (intercetta ESCLUSA)
				while(adj.r.squared.best[steps]+change1>adj.r.squared.best[steps-1]+step.min & steps<=num.max.pred){
					interv<-interv[-which(interv==p.best[steps])] # toglie i vecchi predittori gia' usati dalla lista di quelli che si possono ancora usare
					steps=steps+1 # aggiungiamo ora un predittore nuovo
					r.squared<-adj.r.squared<-c()
					for(p in interv){
						A.xpred<-cbind(A[,mod],A[,mod+p.best],A[,mod+p])  # matrix con i predittori gia selezionati piu quello nuovo
						if(max(abs(cor(A[,mod+p.best],A[,mod+p])))>max.autocorrelation){ # take the maximum value of all the correlations of the the other predictors
							adj.r.squared[p]=-100000 # esclude questo tipo di tempo dalla lista dei possibili predittori, se e' altamente correlato con uno dei precedenti
						} else {
							if(years.missing[st,mese]==0){
								if(negative==FALSE){regr[[p]]<-nnls(as.matrix(A.xpred),b)} else {regr[[p]]<-lm.fit.fast2(A.xpred,b)} # [occhio che la funzione lm.fit non accetta anni mancanti, mentre la funzione nnls si]:
							} else { # se ci sono anni mancanti devo toglierli perche' la funzione lm.fit non accetta anni mancanti (mentre la funzione nnls si):
								if(negative==FALSE){regr[[p]]<-nnls(as.matrix(A.xpred[-years.NA,]),b[-years.NA])} else {regr[[p]]<-lm.fit.fast2(A.xpred[-years.NA,],b[-years.NA])}
								pr.pred<-regr[[p]]$fitted 
								for(i in 1:years.missing[st,mese])pr.pred<-append(pr.pred,NA,after=years.NA[i]-1) # aggiunge al vettore di prec.pred gli anni tolti perche' con prec.oss.mancante (mettendo come valore la NA); in questo modo il vettore con la prec.pred ha tanti elementi quanto gli anni su tutto il periodo di regressione
								regr[[p]]$fitted<-NULL;regr[[p]]$fitted<-pr.pred
							}
							
							if(jacknife.full==TRUE){
								prec.pred.jack<-rep(NA,tot.regr) # vettore che conterra' la prec.calcolata nel periodo di regressione con il jackknife
								# cicla su tutti gli anni di regressione, compresi quelli con prec.oss = NA per calcolare la prec.prevista con il jackknife:
								for(y in 1:tot.regr){ 
									y.regr.buttare<-c(years.NA,y) # fila corrispondenti ad anni ove la prec.oss vale NA e all'anno y da evaluare (come minimo ce n'e' sempre almeno uno, y, quindi puoi scrivere direttamente la linea di codice seguente:)
									if(negative==FALSE){regr.jack<-nnls(as.matrix(A.xpred[-y.regr.buttare,]),b[-y.regr.buttare])} else {regr.jack<-lm.fit.fast2(A.xpred[-y.regr.buttare,],b[-y.regr.buttare])}
									prec.pred.jack[y]<-max(0,A.xpred[y,] %*% regr.jack[[1]]) # calcola la prec.prevista per l'anno y sulla base dei coeff.appena calcolati per il periodo restante
								} # chiude il for su y
								regr[[p]]$fitted<-NULL;regr[[p]]$fitted<-prec.pred.jack # sostituisce invece della prec.predetta normale quella predetta con il jacknife per tutto il periodo della regressione (anche gli anni senza prec.oss)
							}# chiude l'if sul jacknife

							n.pred<-steps+mod    # numero di predittori piu' uno se c'e'l'intercetta
							if(min.rmse==TRUE){
								r.squared[p]<-((sum((regr[[p]]$fitted-b)^2,na.rm=TRUE))/(tot.regr2-n.pred))^0.5 # calcola l'rmse
								adj.r.squared[p]<-(-r.squared[p]) # ribalta il valore di r.squared ovvero del CV perche' cosi'poi quando prendiamo il massimo in realta' prendiamo il valore minimo, che e' quello che ci interessa			
							} else if(min.cv==TRUE){
								r.squared[p]<-((sum((regr[[p]]$fitted-b)^2,na.rm=TRUE))/(tot.regr2-n.pred))^0.5/media.prec.obs[st,mese] # calcola il CV
								adj.r.squared[p]<-(-r.squared[p]) # ribalta il valore di r.squared ovvero del CV perche' cosi'poi quando prendiamo il massimo in realta' prendiamo il valore minimo, che e' quello che ci interessa			
							} else {
								r.squared[p]<-cor(b,regr[[p]]$fitted,use="pairwise.complete.obs")^2 # calcola l'r2 multiplo come quadrato della correlazione tra i valori di prec.osservati e quelli predetti dalla regressione; occhio che quando la correlazione e' zero invece di mettere 0 mette NA
								if(is.na(r.squared[p]))r.squared[p]=0 # vuole dire che i coeff.dei predittori sono tutti 0 tranne quello dell'intercetta
								adj.r.squared[p]<-r.squared[p]-(1-r.squared[p])*n.pred/(tot.regr2-n.pred)
						} # chiude l'else sul tipo di stepwise, se basato sul r2 o sul CV
						} # chiude l'if sulla autocorrelazione
					} # chiude il for su p (il predittore)

					adj.r.squared.best[steps]<-max(adj.r.squared,na.rm=T)
					p.best[steps]<-min(which(adj.r.squared==adj.r.squared.best[steps])) # se per sfiga ci sono due o + predittori con lo stesso R2 adjusted, prende solo il primo dei due
					if(steps<=num.max.pred) coeff.forw.all[steps,,cla,st,mese]<-c(regr[[p.best[steps]]][[1]],rep(NA,num.max.pred+mod-length(regr[[p.best[steps]]][[1]]))) 
				} # chiude il while

				# numero di predittori per la migliore combinazione di predittori trovata (quella che ha R2 adjusted [o CV] piu' alto [basso] o fin quando non gli si e' imposto di fermarsi) per memorizzare i coefficienti:
				n.pred.forw[cla,st,mese]<-(steps-1) # quindi tra n.pred.forw[cla,st,mese] NON e' incluso il termine dato dall'intercetta

				# lista in ordine di importanza dei predittori per la migliore combinazione trovata:
				pred.forw[,cla,st,mese]=c(p.best[1:n.pred.forw[cla,st,mese]],rep(NA,max.nWT-n.pred.forw[cla,st,mese])) # nota che l'intercetta non compare mai nel vettore p.best

			} # chiude l'if sul keepgoing

			setWinProgressBar(barraP,cla+(mese-1)*n.classi,label=paste(st,"/",n.staz.regr) )
		} # chiude il for sulle stazioni (st)
	} # chiude il for sulle classificazioni
} # chiude il for sui mesi
close(barraP) 

###################################################################################################################################################
###							 RICOSTRUZIONE CON LA LEAVE-ONE-OUT CROSS-VALIDATION DELLE PRECIPITAZIONI MENSILI 							 				###
###################################################################################################################################################
# abbiamo gia' i coefficienti della regressione e i loro WTs usati come predittori per la classificazione di riferimento nel periodo di calibrazione;
# ci manca solo di importare i dati dei WT per il periodo da ricostruire, convertirli in valori mensili e calcolare la precipitazione prevista
# sulla base dei coefficienti della regressione di riferimento.
 
#Rprof() # chiudilo con un Rprof(NULL) alla fine del pezzo da controllare

tot.recons<-end.recons-start.recons+1
start.valid2<-start.valid-start.recons+1;end.valid2<-end.valid-start.recons+1 # calcola non l'anno di inizio del periodo per il calcolo della validazione.ma la POSIZIONE di inizio a partire dal primo anno ricostruito
start.regr2<-start.regr-start.recons+1;end.regr2<-end.regr-start.recons+1 # calcola non l'anno di inizio della regressione ma la POSIZIONE di inizio a partire dal primo anno ricostruito

#dimnames(max.pred)<-list(nome.classe,lista.recons,nome.mese)
CV.valid<-CV.calib<-COR.valid<-COR.calib<-array(NA,c(n.classi,n.staz.regr,12,max.nWT)) # nota che la CV.calib fatta con il jacknife e' in effetti come una CV.valid
pixels<-1:n.staz.regr
if(interpol=="NO"){nome.serie<-listaz} else {nome.serie<-1:n.staz.regr}

CV.calib.best<-CV.valid.best<-COR.calib.best<-COR.valid.best<-SS.CV<-SS.COR<-SS.CLI.MSE<-SS.CLI.RMSE<-SS.PER.MSE<-SS.PER.RMSE<-SS.PER2.MSE<-SS.PER2.RMSE<-CV.clim<-array(NA,c(n.classi,n.staz.regr,12),dimnames=list(nome.classe,nome.serie,nome.mese))  # per ogni stazione e mese memorizza il CV e la correlazione migliori finali calcolati sul periodo della regressione (e con il jackknife, se e' stato attivato)
# occhio che la prima componente di CV.xxxx(x,x,x,,) e' il CV o la COR per 0 predittori, non per 1!!!

prec.true<-array(NA,c(n.classi,n.staz.regr,12,tot.recons))  # array (per ora vuoto) con i dati di precipitazione osservata per ogni classe, stazione e mese su tutto il periodo di ricostruzione
prec.rec<-array(NA,c(n.classi,n.staz.regr,12,tot.recons))  # array (per ora vuoto) con i dati di precipitazione ricostruita per ogni classe, stazione e mese

n.series<-length(series) # sono meno di n.staz.regr perche' non si considerano i pixel di mare; se non si interpola invece sono pari a n.staz.regr

barraP<-winProgressBar("Calculating Leave-one-out Cross Validation","Please wait...",0,n.staz.regr,0)
for(st in series){ 
	#st.recons=listaz[st] 
	co<-rmse<-array(NA,c(n.classi,2,12,max.nWT)) # array con memorizzati la correlazione, gli rmse per ogni classificazione mensile e periodo ricostr. e num.di predittori usati(valgono NA per i mesi estivi)
	dimnames(co)<-dimnames(rmse)<-list(nome.classe,c("calibration period","validation period"),nome.mese,1:max.nWT)

	for(mese in int.mesi){
		#dati.temp<-subset(dati.recons,dati.recons[[1]]==st.recons)
		#start.prec.obs<-dati.temp[1,2] # primo anno di dati di prec.osservata
		
		#prec.obs.regr<-subset(matrix.regr,matrix.regr[[1]]==st,select=2+mese)[[1]]  # colonna prec. (seleziona solo le file di prec della serie e del mese che ci interessa):
		prec.obs.regr<-as.numeric(matrix.regr[((st-1)*tot.regr+1):(st*tot.regr),nome.mese.short[mese]]) # estrae la prec.osservata per la serie e il mese desiderato per il periodo di regressione
		
		y.regr.NA<-which(is.na(prec.obs.regr)) # individua gli anni nel periodo di regressione senza un valore di precipitazione 
		#tot.regr2<-tot.regr-length(y.regr.NA) # anni effettivi usati nella regressione

		# se il periodo di ricostruzione parte prima di quello della regressione, deve aggiungere anni di NA!!! 
		if(start.recons<start.regr){prec.obs.recons<-c(rep(NA,start.regr-start.recons),prec.obs.regr) } else {prec.obs.recons<-prec.obs.regr}
		
		# fa lo stesso se il periodo di riconstr.finisce DOPO quello di regr:
		if(end.recons>end.regr)prec.obs.recons<-c(prec.obs.recons,rep(NA,end.recons-end.regr))
		
		# estrae la prec.osservata per il mese precedente (solo per il calcolo del SS.PER2)
		if(mese!=1){previous.month.obs.recons<-matrix.regr[((st-1)*tot.regr+1):(st*tot.regr),1+mese ]} else {temp<-matrix.regr[((st-1)*tot.regr+1):(st*tot.regr),14];previous.month.obs.recons<-c(NA,temp[-(length(temp)+1)]) }
		if(start.recons<start.regr)previous.month.obs.recons<-c(rep(NA,start.regr-start.recons),previous.month.obs.recons) # start.recons per definizione non puo' mai cominciare dopo start.regr
		
		for(cla in cla.rif){
			# coefficienti della regressione della stazione selezionata (il primo coeff.e'quello della intercetta):
			predictors<-na.omit(pred.forw[,cla,st,mese]) # indica quali sono i predittori scelti dalla regressione in ordine di importanza
			if(!is.na(n.pred.forw[cla,st,mese])){
				start.for<-ifelse(only.best==TRUE,n.pred.forw[cla,st,mese],0) # se abbiamo impostato di non fare il ciclo sottostante lo glissiamo facendolo cominciare dall'ultimo step, quello in cui si lavora con il miglior insieme di predittori selezionati dalla regressione
				for(n.pred.used in start.for:n.pred.forw[cla,st,mese]){# cicla sul numero massimo di predittori possibili per quella staz, classificazione e mese:
					if(n.pred.used!=0){
						 # nota che il valore dei coeff.dei predittori cambia in base al numero di predittori che stiamo usando!!! (mentre l'ordine di importanza dei predittori non cambia)
						coeff.used<-na.omit(coeff.forw.all[n.pred.used,,cla,st,mese]) # il primo coeff.e'quello della intercetta, se c'e'; gli altri sono quelli dei predittori in ordine di importanza.

						 # AP e' la matrice con 1 sulla prima colonna (se c'e' l'intercetta) seguita dai predictors in ordine di importanza e una fila per ogni anno ricostruito:
						if(PCRA==TRUE){AP<-as.matrix(PCA.recons[[cla]][[mese]]$scores[,predictors[1:n.pred.used]])} else {AP<-as.matrix(subset(monthlyWT.recons[[cla]],monthlyWT.recons[[cla]][,2]==mese,select=2+predictors[1:n.pred.used]))}
						if(intercept==TRUE)AP<-cbind(1,AP)

						prec.pred.recons<-AP %*% coeff.used # prec.pred.recons e' il vettore con la precipitazione predetta per ogni anno del periodo ricostruito (gia' che c'e' ricostruisce le piogge sia il periodo di validazione che quello di calibrazione)
						prec.pred.recons[which(prec.pred.recons<0)]=0 # i valori di prec.prevista negativi li setta a 0
					} else {prec.pred.recons<-rep(media.prec.obs[st,mese],tot.recons)} # se non ci sono predittori validi, la prec.ricostruita e'pari al valor medio della prec.osservata sul periodo della regressione
					
					tt3<-1:tot.regr
					
					# Attenzione che se abbiamo fatto il jacknife e stiamo considerando almeno un predittore,
					# durante il periodo di regressione dobbiamo sostituire la prec.predetta senza il jacknife con quella predetta con il jacknife:
					if(jacknife==TRUE & n.pred.used!=0){
						prec.pred.jack<-rep(NA,tot.regr) # vettore che conterra' la prec.calcolata nel periodo di regressione con il jackknife
						regr<-list()
						# AP.regr e' come AP ma solo per il periodo di regressione:
						if(PCRA==TRUE){AP.regr<-as.matrix(PCA.regr[[cla]][[mese]]$scores[,predictors[1:n.pred.used]])} else {AP.regr<-as.matrix(subset(monthlyWT.regr[[cla]],monthlyWT.regr[[cla]][,2]==mese,select=2+predictors[1:n.pred.used]))}
						if(intercept==TRUE)AP.regr<-cbind(1,AP.regr)
						# cicla su tutti gli anni di regressione, compresi quelli con prec.oss = NA per calcolare la prec.prevista con il jackknife:
						for(y in 1:tot.regr){ 
							y.regr.buttare<-c(y.regr.NA,y) # fila corrispondenti ad anni ove la prec.oss vale NA e all'anno y da evaluare
							if(negative==FALSE){regr[[y]]<-nnls(as.matrix(AP.regr[-y.regr.buttare,]),prec.obs.regr[-y.regr.buttare])} else {regr[[y]]<-lm.fit.fast2(AP.regr[-y.regr.buttare,],prec.obs.regr[-y.regr.buttare]);regr[[y]][[1]]<-replace(regr[[y]][[1]],which(is.na(regr[[y]][[1]])),0)} # stranamente i coefficienti della regressione pari a 0 vengono scritti come NA dall'algoritmo lm.fit, percio'devo rimetterli uguali a 0 se no la prossima riga mi introduce NA come valore di prec.ricostruita
							if(predictand=="PREC"){
								prec.pred.jack[y]<-max(0,AP.regr[y,] %*% regr[[y]][[1]]) # calcola la prec.prevista per l'anno y sulla base dei coeff.appena calcolati per il periodo restante
							} else {
								prec.pred.jack[y]<-AP.regr[y,] %*% regr[[y]][[1]] # because temperature can also be negative
							}
						} # chiude il for su y
						prec.pred.recons[start.regr2+tt3-1]<-prec.pred.jack # sostituisce al posto della prec.predetta con i coefficienti per tutto il periodo di regr, la prec.predetta usando lo STESSO numero e tipi di predittori, ma coefficienti diversi per ogni anno calcolati escludendo l'anno selezionato dalla regressione (solo per gli anni del periodo di regr.che hanno una prec.osservata; gli altri li lascia uguali alla previsione con i coeff.senza il jacknife, cioe' a prec.pred.recons)
					}  # chiude l'if sul jacknife

					prec.pred.regr<-prec.pred.recons[start.regr2+tt3-1] # passa dalla prec. prevista nel periodo ricostruito a quella prevista nel periodo della regressione

					# conserva i valori del RMSE e della CORRELAZIONE per le due classificazioni, i due periodi e per ogni mese per poterli tabulare alla fine:
					#rmse[cla,1,mese,1+n.pred.used]<-RMSE(prec.obs.regr,prec.pred.regr,length(prec.obs.regr)-n.pred.used-mod) # usa questa nuova notazione per selezionare tutti gli anni nel periodo di regressione
					#rmse[cla,2,mese,1+n.pred.used]<-RMSE(prec.obs.recons[start.valid2:end.valid2],prec.pred.recons[start.valid2:end.valid2],length(prec.obs.recons[start.valid2:end.valid2])-n.pred.used-mod) # deviazione standard riferita stavolta al periodo per il calcolo della validazione (coincide con dev.snd.err); se ci sono anni con prec.obs=NA nella funzione RMSE vengono tolti
					#tt1<-cor(prec.obs.regr,prec.pred.regr) # cosi' non ci sono mai valori di correlazione pari ad NA (a meno che a prec.pred.recons non abbia valore costante perche' ottenuta come media della prec.osservata)
					#co[cla,1,mese,1+n.pred.used]<-ifelse(is.na(tt1),0,tt1) 
					#tt2<-cor(prec.obs.recons[start.valid2:end.valid2],prec.pred.recons[start.valid2:end.valid2],use="complete.obs") # gli NA nei dati di input ci possono essere ma vengono tolti nel calcolo della correlazione  grazie alla opzione complete.obs
					#co[cla,2,mese,1+n.pred.used]<-ifelse(is.na(tt2),0,tt2) # per mettere a 0 la correlazione che vale NA quando uno dei due vettori di input e' un vettore costante
					#conf95%<-1.96*dev.snd.err
					#rmse<-round(rmse,1)
				} # chiude il for sul n.pred.used
			} # chiude l'if sulla possibilita' di avere almeno un predittore

			prec.true[cla,st,mese,]<-prec.obs.recons # memorizza la prec.osservata per tutto il periodo di ricostruzione (vale NA se i primi anni sono senza dati osservati)
			prec.rec[cla,st,mese,]<-prec.pred.recons # memorizza la prec.ricostruita [con il jacknife se lo si e'impostato] per tutto il periodo di ricostruzione 
			
			#temp.cal<-(rmse[cla,1,mese,]/media.prec.obs[st,mese])[1:(1+n.pred.forw[cla,st,mese])] # seleziona i CV da 0 predittori fino a n.pred.forw per il periodo di regressione
			#temp.val<-(rmse[cla,2,mese,]/media.prec.obs[st,mese])[1:(1+n.pred.forw[cla,st,mese])] # seleziona i CV da 0 predittori fino a n.pred.forw per il periodo di validazione
			#CV.calib[cla,st,mese,]<-c(temp.cal,rep(NA,max.nWT-length(temp.cal)))# occhio che la prima componente di CV.xxxx(x,x,x,,) e' il CV per 0 predittori, non per 1!!!
			#CV.valid[cla,st,mese,]<-c(temp.val,rep(NA,max.nWT-length(temp.val)))# occhio che la prima componente di CV.xxxx(x,x,x,,) e' il CV per 0 predittori, non per 1!!!
			#CV.calib.best[cla,st,mese]<-CV.calib[cla,st,mese,1+n.pred.forw[cla,st,mese]] # CV con il numero ottimale di predittori trovato dalla regressione per il periodo di calibrazione
			#CV.valid.best[cla,st,mese]<-CV.valid[cla,st,mese,1+n.pred.forw[cla,st,mese]] # CV con il numero ottimale di predittori trovato dalla regressione per il periodo di validazione
			
			#temp.cal<-(co[cla,1,mese,])[1:(1+n.pred.forw[cla,st,mese])]
			#temp.val<-(co[cla,2,mese,])[1:(1+n.pred.forw[cla,st,mese])]
			#COR.calib[cla,st,mese,]<-c(temp.cal,rep(NA,max.nWT-length(temp.cal))) # lo calcolo ma poi non lo disegno # occhio che la prima componente di COR.xxxx(x,x,x,,) e' la COR per 0 predittori, non per 1!!!
			#COR.valid[cla,st,mese,]<-c(temp.val,rep(NA,max.nWT-length(temp.val))) # lo calcolo ma poi non lo disegno
			#COR.calib.best[cla,st,mese]<-COR.calib[cla,st,mese,1+n.pred.forw[cla,st,mese]] # COR con il numero ottimale di predittori trovato dalla regressione per il periodo di calibrazione
			#COR.valid.best[cla,st,mese]<-COR.valid[cla,st,mese,1+n.pred.forw[cla,st,mese]] # COR con il numero ottimale di predittori trovato dalla regressione per il periodo di validazione
			
			# skill scores del CV del modello nel periodo di validazione vs. il CV del modello nel periodo di calibrazione (idem per la COR):
			#SS.CV[cla,st,mese]<-(CV.calib.best[cla,st,mese]-CV.valid.best[cla,st,mese])/CV.calib.best[cla,st,mese]
			#SS.COR[cla,st,mese]<-(COR.calib.best[cla,st,mese]-COR.valid.best[cla,st,mese])/COR.calib.best[cla,st,mese]
			
			# skill scores del MSE e del RMSE (che sono pure uguali allo SS rispoettivamente del CV^2 e del CV) del modelo comparado con CV calculado cuando la prec.predicha es igual a la climatolgy (el promedio mensual de prec.)
			#mean.prec.obs<-mean(prec.obs.recons[start.valid2:end.valid2],na.rm=T)
			#CV.clim[cla,st,mese]<-RMSE(prec.obs.recons[start.valid2:end.valid2],rep(mean.prec.obs,end.valid2-start.valid2+1),length(prec.obs.recons[start.valid2:end.valid2])-n.pred.used-1)/mean.prec.obs # ho dovuto considerare lo stesso numero di gradi di liberta'del CV(RMSE) per poter confrontare i due CV
			#SS.CLI.MSE[cla,st,mese]<-((CV.valid.best[cla,st,mese])^2-(CV.clim)^2)/(-(CV.clim)^2)
			#SS.CLI.RMSE[cla,st,mese]<-(CV.valid.best[cla,st,mese]-CV.clim[cla,st,mese])/(-CV.clim[cla,st,mese])
			
			# skill scores del MSE e del RMSE basati sulla persistenza invece della climatologia dello stesso mese dell'anno precedente
			#mean.prec.obs<-mean(prec.obs.recons[start.valid2:end.valid2],na.rm=T)
			#previous.prec.obs<-c(NA,prec.obs.recons[start.valid2:end.valid2])[-(length(prec.obs.recons[start.valid2:end.valid2])+1)] # vettore come prec.obs.recons ma sfasato di uno in modo che ad ogni valore mensile corrisponda quello del mese dell'anno precedente
			#CV.per<-RMSE(prec.obs.recons[start.valid2:end.valid2],previous.prec.obs)/mean.prec.obs
			#SS.PER.MSE[cla,st,mese]<-((CV.valid.best[cla,st,mese])^2-(CV.per)^2)/(-(CV.per)^2)
			#SS.PER.RMSE[cla,st,mese]<-(CV.valid.best[cla,st,mese]-CV.per)/(-CV.per)
			
			# skill scores del MSE e del RMSE basati sulla persistenza DEL MESE ANTERIORE invece dello stesso mese ma dell'anno prima
			#CV.per<-RMSE(prec.obs.recons[start.valid2:end.valid2],previous.month.obs.recons[start.valid2:end.valid2])/mean.prec.obs
			#SS.PER2.MSE[cla,st,mese]<-((CV.valid.best[cla,st,mese])^2-(CV.per)^2)/(-(CV.per)^2)
			#SS.PER2.RMSE[cla,st,mese]<-(CV.valid.best[cla,st,mese]-CV.per)/(-CV.per)
			
		} # chiude il for sulle classificazioni
	} # chiude il for sul mese
	setWinProgressBar(barraP,st,label=paste(st,"/",n.series))
};close(barraP)  # chiude il for sulla serie st

# calcolo valori medi del CV e della prec.osservata e prevista su tutte le serie: 
#CV.valid.mean<-CV.calib.mean<-COR.valid.mean<-COR.calib.mean<-array(NA,c(n.classi,12,max.nWT))
#CV.calib.best.mean<-CV.valid.best.mean<-array(NA,c(n.classi,12))
#prec.true.mean<-prec.rec.mean<-array(NA,c(n.classi,n.staz.regr,12)) # prec.osservata media e prec.predetta media su tutto il periodo di ricostruzione per ogni stazione e mese e classe
#for(cla in cla.rif){
#for(mese in int.mesi){
	#CV.calib.mean[cla,mese,]<-apply(CV.calib[cla,,mese,],2,mean,na.rm=T) #(non funziona se c'e' solo una serie) perche' apply necessita di piu' di una colonna/riga
	#CV.valid.mean[cla,mese,]<-apply(CV.valid[cla,,mese,],2,mean,na.rm=T) # (non funziona se c'e' solo una serie) perche' apply necessita di piu' di una colonna/riga
#	CV.calib.best.mean[cla,mese]<-mean(CV.calib.best[cla,,mese],na.rm=T)
#	CV.valid.best.mean[cla,mese]<-mean(CV.valid.best[cla,,mese],na.rm=T)
	#COR.calib.mean[cla,mese,]<-apply(COR.calib[cla,,mese,],2,mean,na.rm=T) #(non funziona se c'e' solo una serie) perche' apply necessita di piu' di una colonna/riga
	#COR.valid.mean[cla,mese,]<-apply(COR.valid[cla,,mese,],2,mean,na.rm=T) #(non funziona se c'e' solo una serie) perche' apply necessita di piu' di una colonna/riga
#	for(st in series){
#		prec.true.mean[cla,st,mese]<-mean(prec.true[cla,st,mese,],na.rm=T)
#		prec.rec.mean[cla,st,mese]<-mean(prec.rec[cla,st,mese,],na.rm=T)
#		sd.true[cla,st,mese]<-sd(prec.true[cla,st,mese,],na.rm=T)
#		sd.rec[cla,st,mese]<-sd(prec.rec[cla,st,mese,],na.rm=T)
#	} # chiude il for su staz
#}}

# CORREZIONE ERRORI SISTEMATICI e CALCOLO CV e COR e MBE per il periodo di VALIDAZIONE:
# (praticamente si aggiunge alla prec.rec il segmento pari alla distanza tra la retta di regressione e la retta y=x dove la prec.prevista e' pari a quella osservata)
# purtroppo si puo'solo correggere la prec.predetta (e quindi migliorare il CV); non si possono correggere anche i coefficienti dei singoli predittori, cosa che sarebbe utile per migliorare la precisione delle mappe dei contributi di ogni WT alla precipitazione
prec.rec.no.sys<-array(NA,c(n.classi,n.staz.regr,12,tot.recons)) 
RMSE.valid.best<-MBE.valid.best<-CV.valid.best<-CV.valid.best.no.sys<-SS.CLI.RMSE<-SS.CLI.RMSE.no.sys<-COR.valid.best<-COR.valid.best.no.sys<-array(NA,c(n.classi,n.staz.regr,12),dimnames=list(nome.classe,nome.serie,nome.mese))
CV.MAE<-d.Willmott<-d.Willmott.1<-d.Willmott.2011<-CV.MBE<-array(NA,c(n.classi,n.staz.regr,12),dimnames=list(nome.classe,nome.serie,nome.mese))
sd.true<-sd.rec<-array(NA,c(n.classi,n.staz.regr,12)) # dev.standard prec.osservata e dev.standard prec.predetta su tutto il periodo di ricostruzione per ogni stazione e mese e classe
aa<-bb<-RMSEs<-RMSEn<-proportion<-array(NA,c(n.classi,n.staz.regr,12)) # coeff.regressione per trovare l'RMSE sistematico (aa e' il termine noto) , RMSE sistematico e RMSE normale (quello classico) e rapporto tra i due
normality<-array(NA,c(n.classi,n.staz.regr,12)) # P-value che indica se se i residui seguono una distr.normale (test Shapiro-Wilks). Piu'il numero e' basso piu' e' probabile che la distribuzione non sia normale.

barraP<-winProgressBar("Validating...","",0,length(int.mesi),0); i=0
for(cla in cla.rif){
for(mese in int.mesi){
for(st in series){
	pr.true<-prec.true[cla,st,mese,][start.regr2+tt3-1]# prec.osservata nel periodo di regressione
	pr.rec<-prec.rec[cla,st,mese,][start.regr2+tt3-1] # prec.prevista [con il jackknife se lo si e'impostato] nel periodo di regressione

	#normality[cla,st,mese]<-shapiro.test(pr.rec-pr.true)$p.value
	
	# prima calcola il RMSE, CV e la COR prima della correzione dell'errore sistematico:
	RMSE.valid.best[cla,st,mese]<-RMSE(prec.true[cla,st,mese,][start.valid2:end.valid2],prec.rec[cla,st,mese,][start.valid2:end.valid2])
	CV.valid.best[cla,st,mese]<-RMSE.valid.best[cla,st,mese]/media.prec.obs[st,mese] 
	CV.clim[cla,st,mese]<-RMSE(prec.true[cla,st,mese,][start.valid2:end.valid2],rep(media.prec.obs[st,mese],end.valid2-start.valid2+1))/media.prec.obs[st,mese] 
	SS.CLI.RMSE[cla,st,mese]<-(CV.valid.best[cla,st,mese]-CV.clim[cla,st,mese])/(-CV.clim[cla,st,mese])
	MBE.valid.best[cla,st,mese]<-MBE(prec.true[cla,st,mese,][start.valid2:end.valid2],prec.rec[cla,st,mese,][start.valid2:end.valid2])
	sd.true[cla,st,mese]<-sd(prec.true[cla,st,mese,],na.rm=T)
	sd.rec[cla,st,mese]<-sd(prec.rec[cla,st,mese,],na.rm=T)
	
	# calcola il CV(MAE) invece del CV(RMSE) e la d di Willmot e il CV(MBE)
	CV.MAE[cla,st,mese]<-MAE(prec.true[cla,st,mese,][start.valid2:end.valid2],prec.rec[cla,st,mese,][start.valid2:end.valid2])/media.prec.obs[st,mese] 
	d.Willmott[cla,st,mese]<-AGREE(prec.true[cla,st,mese,][start.valid2:end.valid2],prec.rec[cla,st,mese,][start.valid2:end.valid2])
	d.Willmott.1[cla,st,mese]<-AGREE.1(prec.true[cla,st,mese,][start.valid2:end.valid2],prec.rec[cla,st,mese,][start.valid2:end.valid2])
	d.Willmott.2011[cla,st,mese]<-AGREE.2011(prec.true[cla,st,mese,][start.valid2:end.valid2],prec.rec[cla,st,mese,][start.valid2:end.valid2])
	CV.MBE[cla,st,mese]<-MBE.valid.best[cla,st,mese]/media.prec.obs[st,mese] 
	
	# corregge l'errore sistematico anche per gli anni fuori dall'intervallo di regressione, ma usando solo i punti degli anni di regressione per il calcolo della retta di regressione che si usa per la correzione dell'errore sistematico	
	years.NA<-which(is.na(pr.true)) 
	if(length(years.NA)==0){pr.true2<-pr.true;pr.rec2<-pr.rec} else {pr.true2<-pr.true[-years.NA];pr.rec2<-pr.rec[-years.NA]} # toglie i mesi senza un valore di precipitazione osservata (se ci sono) per poter fare il fit
	my.fit<-lm.fit.fast2(cbind(1,pr.true2),pr.rec2) # deve fare il fit solo sul periodo di regressione!!! (occhio che non puoi piu' usare lm.fit.fast con la nuova versione di R)
	aa[cla,st,mese]<-my.fit$coefficients[1] # intercetta
	bb[cla,st,mese]<-my.fit$coefficients[2] # pendenza
	RMSEs[cla,st,mese]<-RMSE(pr.rec2,my.fit$fitted.values) # serve solo per calcolare la grandezza 'proportion'
	RMSEn[cla,st,mese]<-RMSE(pr.true2,pr.rec2)
	proportion[cla,st,mese]<-RMSEs[cla,st,mese]/RMSEn[cla,st,mese]
	prec.rec.no.sys[cla,st,mese,]<-prec.rec[cla,st,mese,]+prec.true[cla,st,mese,]-(aa[cla,st,mese]+bb[cla,st,mese]*prec.true[cla,st,mese,])
	prec.rec.no.sys[cla,st,mese,ss<-which(prec.rec.no.sys[cla,st,mese,]<0)]=0
	
	# calcola il nuovo CV e SS(CV)dopo la correzione (sul periodo di validazione):
	#CV.valid.best.sys[cla,st,mese]<-RMSE(prec.obs.recons[start.valid2:end.valid2],prec.pred.recons[start.valid2:end.valid2],length(prec.obs.recons[start.valid2:end.valid2])-n.pred.used-mod)/media.prec.obs[st,mese] # deviazione standard riferita stavolta al periodo per il calcolo della validazione (coincide con dev.snd.err); se ci sono anni con prec.obs=NA nella funzione RMSE vengono tolti	
	#CV.valid.best[cla,st,mese]<-RMSE(prec.true[cla,st,mese,][start.valid2:end.valid2],prec.rec[cla,st,mese,][start.valid2:end.valid2],length(prec.true[cla,st,mese,][start.valid2:end.valid2])-n.pred.used-mod)/media.prec.obs[st,mese] 
	#CV.valid.best.sys[cla,st,mese]<-RMSE(prec.true[cla,st,mese,][start.valid2:end.valid2],prec.rec.no.sys[cla,st,mese,][start.valid2:end.valid2],length(prec.true[cla,st,mese,][start.valid2:end.valid2])-n.pred.used-mod)/media.prec.obs[st,mese] # deviazione standard riferita stavolta al periodo per il calcolo della validazione (coincide con dev.snd.err); se ci sono anni con prec.obs=NA nella funzione RMSE vengono tolti	
	CV.valid.best.no.sys[cla,st,mese]<-RMSE(prec.true[cla,st,mese,][start.valid2:end.valid2],prec.rec.no.sys[cla,st,mese,][start.valid2:end.valid2])/media.prec.obs[st,mese] # deviazione standard riferita stavolta al periodo per il calcolo della validazione (coincide con dev.snd.err); se ci sono anni con prec.obs=NA nella funzione RMSE vengono tolti	
	SS.CLI.RMSE.no.sys[cla,st,mese]<-(CV.valid.best.no.sys[cla,st,mese]-CV.clim[cla,st,mese])/(-CV.clim[cla,st,mese]) # skill score del RMSE (che e' pure pari allo SS del CV) riferito alla climatologia
	
	# idem ma per la COR invece del CV:
	tt<-cor(prec.true[cla,st,mese,][start.valid2:end.valid2],prec.rec[cla,st,mese,][start.valid2:end.valid2])
	COR.valid.best[cla,st,mese]<-ifelse(is.na(tt),0,tt) 
	tt<-cor(prec.true[cla,st,mese,][start.valid2:end.valid2],prec.rec.no.sys[cla,st,mese,][start.valid2:end.valid2])
	COR.valid.best.no.sys[cla,st,mese]<-ifelse(is.na(tt),0,tt) 
}
i=i+1
setWinProgressBar(barraP,i)
}};close(barraP)

tabla1<-round(CV.valid.best,2)
#tabla1<-tabla1[,,c(int.mesi)] # riordina la tabella facendo cominciare i mesi da ottobre
#tabla1[cla.rif,,]
tabla2<-round(COR.valid.best,2)
#tabla2<-tabla2[,,c(int.mesi)] # riordina la tabella facendo cominciare i mesi da ottobre
#tabla2[cla.rif,,]
tabla3<-round(SS.CLI.RMSE,2)
#tabla3<-tabla3[,,c(int.mesi)] # riordina la tabella facendo cominciare i mesi da ottobre
#tabla3[cla.rif,,]
tabla4<-rbind(tabla1[cla.rif,,],tabla2[cla.rif,,],tabla3[cla.rif,,])
#tabla4

if(altro==T){######################## Grafici di CV e di COR in funzione del numero di predittori usati nella regressione ###########################
	predmax<-rep(6,12) #predmax<-c(10,10,10,0,0,0,0,0,0,10,10,10) # num.max. di predittori per mese da calcolare e mostrare nei grafici
	st.interv2<-series[2301:2320] # estrae un sottoinsieme di series perche' piu' di 63 grafici non si possono visualizzare con R
	tipo=2 # vale 1 se vuoi un grafico per ogni mese, 2 se vuoi tutte le curve dei mesi nello stesso grafico
	y.min<-0.3 
	y.max<-0.8 

	for(st in st.interv2){
		st.recons=lista.recons[st] 
		windows() # se non vuoi salvare su .pdf
		if(tipo==1){par(mfrow=graph.yx);par(oma=c(1,1,3,1));  par(mar=c(2,2,2,2))} # oma controlla il bordo esterno a tutti i grafici, mar i bordi interni tra grafici
		#pdf(paste(dir_root,"/COR y RMSE vs Num.predictors.pdf",sep="")) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
		if(tipo==2)print(plot(rep(0,predmax[mese]),type="n",xlab="Number of WTs predictors", ylab="CV",ylim=c(y.min,y.max),yaxp=c(y.min,y.max,(y.max-y.min)*10),xlim=c(0,predmax[mese]),xaxp=c(0,predmax[mese],predmax[mese]))) # stampa un grafico vuoto con gli assi e basta

		for(mese in int.mesi){
			for(cla in cla.rif){
				if(tipo==1)print(plot(rep(0,predmax[mese]),type="n",xlab="Num.of predictors used", ylab="CV",ylim=c(y.min,y.max),yaxp=c(y.min,y.max,(y.max-y.min)*10),xlim=c(0,predmax[mese]),xaxp=c(0,predmax[mese],predmax[mese]))) # stampa un grafico vuoto con gli assi e basta
				print(lines(0:(max.nWT-1),CV.calib[cla,st,mese,],type="o",col=month.color[mese],cex=.6)) # stampa la linea del RMSE per il periodo del calcolo della
				# bonta' della ricostruzione ricostruzione
				# print(lines(CV.valid[cla,st,mese,],type="o",col=class.color[cla],cex=.6,lty=2)) # stampa la linea del RMSE per il periodo di calibrazione regressione
				# min.pred<-min(which(CV.calib[cla,st,mese,]==min.CV),na.rm=T)
				#print(points(min.pred,min.CV,col=class.color[cla],cex=1.4))
			} # chiude il for sulle 2 classificazioni da disegnare nella stessa finestra

			if(tipo==1)title(nome.mese[mese],line=0.5,cex=1.1)
		} # chiude il for sul mese

		if(tipo==2)legend("topright",nome.mese[int.mesi],col=month.color[int.mesi],lwd=.8)
		mtext(paste("CV for",nome.classe[2],"(station #",st,infofile@data[[2]][st],")"),outer=T,cex=1.2)
	}# chiude il for sulla stazione st
	#dev.off() # solo se si vogliono visualizzare i grafici in formato .pdf

	###################### Grafici andamento temporale prec.osservata e ricostruita per una serie a piacere o per un mese a piacere #################################

	# visualizza una serie per ogni mese della stazione scelta:
	par(mfrow=c(length(int.mesi),1));par(oma=c(1,1,1,1));  par(mar=c(2,2,2,2)) # oma controlla il bordo esterno a tutti i grafici, mar i bordi interni tra grafici
	st.rif<-series[1] # scegli una stazione da graficare (es: 3195=Madrid; 32/01C = Lisboa;  8416=Valencia)
	#windows() # se non vuoi salvare su .pdf
	for(mese in int.mesi){
		y.min=0;y.max=max(max(prec.true[cla.rif,st.rif,mese,],na.rm=T),max(prec.rec[cla.rif,st.rif,mese,],na.rm=T))
		print(plot(rep(0,tot.recons),type="n",xlab="Year", ylab="mm",ylim=c(y.min,y.max),xlim=c(start.recons,end.recons),xaxt='n')) # stampa un grafico vuoto con gli assi e basta
		print(lines(start.recons:end.recons,prec.true[cla.rif,st.rif,mese,],type="o",col="black",cex=.6)) # stampa la linea del RMSE per il periodo del calcolo della bonta' della ricostruzione ricostruzione
		print(lines(start.recons:end.recons,prec.rec[cla.rif,st.rif,mese,],type="o",col=month.color[mese],cex=.6)) # stampa la linea del RMSE per il periodo del calcolo della bonta' della ricostruzione ricostruzione
		axis(1,at=seq(start.recons,end.recons,10))
		#title(paste(nome.mese[mese],"(CV calib =",round(CV.calib.best[cla.rif,st.rif,mese],2),")"),line=0.5,cex=1.1)
	}

	# visualizza invece solo le serie del mese scelto per tutte le stazioni (Figura 9 articulo WTs #1):
	par(mfrow=c(length(series),1));par(oma=c(1,1,1,1));  par(mar=c(2,2,2,2)) # oma controlla il bordo esterno a tutti i grafici, mar i bordi interni tra grafici
	mese.rif=1
	for(st in series[c(2,1,3)]){
		y.min=0;y.max=max(max(prec.true[cla.rif,st,mese.rif,],na.rm=T),max(prec.rec[cla.rif,st,mese.rif,],na.rm=T))
		print(plot(rep(0,tot.recons),type="n",xlab="Year", ylab="mm",ylim=c(y.min,y.max),xlim=c(start.recons,end.recons),xaxt='n')) # stampa un grafico vuoto con gli assi e basta
		print(lines(start.recons:end.recons,prec.true[cla.rif,st,mese.rif,],type="o",col="black",cex=.6)) # stampa la linea del RMSE per il periodo del calcolo della bonta' della ricostruzione ricostruzione
		print(lines(start.recons:end.recons,prec.rec[cla.rif,st,mese.rif,],type="o",col=month.color[st],cex=.6)) # stampa la linea del RMSE per il periodo del calcolo della bonta' della ricostruzione ricostruzione
		axis(1,at=seq(start.recons,end.recons,10),cex=2.0)
		title(paste(series[st],". ",infofile[[2]][st]),cex=.1) #,"(CV calib =",round(CV.calib.best[cla.rif,st,mese.rif],2),")"),line=0.5,cex=20.4)
	}
	############### SCATTERPLOT PREDICTED PREC vs. OBSERVED PREC durante il periodo di RICOSTRUZIONE fissati una serie e un mese ##########################################################
	# (utile per VEDERE l'errore sistematico, se c'e')

	st.rif<-3 # scegli una stazione da graficare (vedi sopra)
	mese.rif<-12 # scegli un mese da graficare dentro i valori assunti da int.mesi

	#pr.true<-prec.true[cla.rif,st.rif,mese.rif,] # per fare lo scatterplot su todo el periodo de reconstruccion
	#pr.rec<-prec.rec[cla.rif,st.rif,mese.rif,] # per fare lo scatterplot su todo el periodo de reconstruccion
	pr.true<-prec.true[cla.rif,st.rif,mese.rif,][start.regr2+tt3-1] # se vuoi fare lo scatterplot solo sul periodo della regressione
	pr.rec<-prec.rec[cla.rif,st.rif,mese.rif,][start.regr2+tt3-1] # se vuoi fare lo scatterplot solo sul periodo della regressione
	years.NA<-which(is.na(pr.true)) 
	if(length(years.NA)==0){pr.true2<-pr.true;pr.rec2<-pr.rec} else {pr.true2<-pr.true[-years.NA];pr.rec2<-pr.rec[-years.NA]} # toglie i mesi senza un valore di precipitazione osservata (se ci sono)
	x.min=0;x.max<-300#x.max<-max(pr.true2,na.rm=T)
	y.min=0;y.max<-300 #y.max<-max(pr.rec2,na.rm=T)
	#par(mfrow=c(1,2))
	plot(pr.true2,pr.rec2,xlab="Obs.prec.(mm)", ylab="Pred.prec.(mm)",ylim=c(y.min,y.max),xlim=c(x.min,x.max),cex=1.0)
	lines(0:x.max,0:x.max,lty=3) # bisettrice del primo quadrante che coincide con la retta del fit perfetto
	#lines(pr.true2,aa[cla.rif,st.rif,mese.rif]+bb[cla.rif,st.rif,mese.rif]*pr.true2) # linea regressione punti previsti e osservati
	title(paste("VALENCIA"),line=0.5,cex=1.1) #title("Before correction")

	# grafico dopo l'eliminazione dell'errore sistematico:
	#plot(prec.true[cla,st.rif,mese.rif,],prec.rec.no.sys[cla,st.rif,mese.rif,])
	#lines(0:x.max,0:x.max,lty=3) # bisettrice del primo quadrante che coincide con la retta del fit perfetto
	#title("After correction")
	
	### TABLE 3 Article WTs: (calculo MAE% solo per due periodi a scelta)
	#il MAE% ? uguale a MAEp<-mean(abs(prec.rec[cla,st,mese,]-prec.true[cla,st,mese,]))/mean(prec.true[cla,st,mese,]) o usando la funzione MAEp()
	my.start=1871
	my.end=1944
	MAEperc1<-c();for(mese in 1:12)MAEperc1[mese]<-MAEp(prec.true[cla,st,mese,][(my.start-start.recons+1):(my.end-start.recons+1)],prec.rec[cla,st,mese,][(my.start-start.recons+1):(my.end-start.recons+1)])
	my.start2=1945
	my.end2=2005
	MAEperc2<-c();for(mese in 1:12)MAEperc2[mese]<-MAEp(prec.true[cla,st,mese,][(my.start2-start.recons+1):(my.end2-start.recons+1)],prec.rec[cla,st,mese,][(my.start2-start.recons+1):(my.end2-start.recons+1)])
	#MAEperc1<-(MAEperc1^0.5)/10 # correzione per rettificare l'errore nel calcolo del MAE!!!
	#MAEperc2<-(MAEperc2^0.5)/10 # correzione per rettificare l'errore nel calcolo del MAE!!!
	rbind(MAEperc1,MAEperc2,(MAEperc2-MAEperc1)/MAEperc1) # # MAE% primo periodo, MAE% secondo periodo e Percentage difference per ogni mese
	
	########################### HETEROSCEDASTICITY #############################################################################################
	# visualizza se per una serie fissata il valore assoluto dei residuali della regressione cresce all'aumentare della prec.predetta

	st.rif<-3030 # scegli una stazione da graficare (es: 3030 = Lisboa)

	par(mfrow=c(3,4))
	for(mese in int.mesi){
		residual<-prec.rec.no.sys[cla,st.rif,mese,]-prec.true[cla,st.rif,mese,]
		plot(prec.rec.no.sys[cla,st.rif,mese,],residual)
		x.max<-max(prec.rec.no.sys[cla,st.rif,mese,],na.rm=T)
		# par("new") oppure:
		lines(0:x.max,rep(0,length(0:x.max)),lty=3) # bisettrice del primo quadrante che coincide con la retta del fit perfetto
		title(nome.mese[mese])
	}

	# idem ma se vuoi vedere anche com'era prima di eliminare l'errore sistematico (colore ROSSO):
	windows()
	par(mfrow=c(3,4))
	for(mese in int.mesi){
		residual<-prec.rec[cla,st.rif,mese,]-prec.true[cla,st.rif,mese,]
		plot(prec.rec[cla,st.rif,mese,],residual)
		x.max<-max(prec.rec.no.sys[cla,st.rif,mese,],na.rm=T)
		# par("new") oppure:
		lines(0:x.max,rep(0,length(0:x.max)),lty=3,col="red") # bisettrice del primo quadrante che coincide con la retta del fit perfetto
		title(nome.mese[mese])
	}

	######################### Mappa anomalie prec.ricostruita durante episodi di alluvioni ####################################################3
	anno.rif=1909 # scegli un anno all'interno del periodo di ricostruzione
	mese.rif=12  # scegli un mese
	start.anom=1971 # anno d'inizio per il calcolo delle anomalie
	end.anom=2000

	my.polygon<-list('sp.polygons',IpPoly,fill='transparent',first=F) # first=FALSE gli dice di NON disegnare il poligono per primo # altre opzioni di list: fill=0, lwd=3, lty=2
	my.layout<-list(my.polygon)

	prec.pred.name<-paste("Predicted Monthly Precipitation for",nome.mese[mese.rif],anno.rif)
	prec.pred.levels<-c(seq(0,2000,100),2500,3000,4000,5000,6000,100000)
	prec.pred.data<-infofile
	prec.pred.data[[4+mese]]<-prec.rec[cla.rif,,mese,anno.rif-start.recons+1] # prec.prevista per quel anno e mese
	names(prec.pred.data)[[4+mese]]<-nome.mese[mese]
	windows()
	print(spplot(prec.pred.data,nome.mese[mese],key.space = "right",cuts=prec.pred.levels,col.regions=rev(jet.colors2(1000)),main=prec.pred.name,sp.layout=my.layout,pch=19,cex=0.5))

	anom.pred.name<-paste("Predicted Monthly Precipitation Anomaly for",nome.mese[mese.rif],anno.rif)
	anom.pred.levels<-c(-10,-5,-4,-3,-2,seq(-1,1,0.1),2,3,4,5,10)
	anom.pred.data<-infofile
	start.anom2<-start.anom-start.recons+1;end.anom2<-end.anom-start.recons+1
	anom.pred.data[[4+mese]]<-prec.rec[cla.rif,,mese,anno.rif-start.recons+1]/apply(prec.true[cla.rif,,mese,start.anom2:end.anom2],2,mean) # prec.prevista per quel anno e mese
	names(prec.pred.data)[[4+mese]]<-nome.mese[mese]
	windows()
	print(spplot(anom.pred.data,nome.mese[mese],key.space = "right",cuts=prec.pred.levels,col.regions=rev(jet.colors2(1000)),main=prec.pred.name,sp.layout=my.layout,pch=19,cex=0.5))
	# finisci...

	################################ Istogramma di frequenze del numero di predittori in funzione del mese #############################################
	hist(n.pred.forw[cla.rif,,],breaks=8,right=F,freq=F,density=40,angle=45,col="black",xlab="Number of Predictors",ylab="Frequency",axes=F)
	axis(1,at=0.5:8.5,labels=0:8)
	axis(2,0.05*0:6)

	# istogrammi di freq.del numero di predittori in funzione del WT e del mese:
	par(mfrow=graph.yx);par(oma=c(2,0,0,0));  par(mar=c(2,4,4,2)) # oma controlla il bordo esterno a tutti i grafici, mar i bordi interni tra grafici
	for(mese in int.mesi){
	hist(pred.forw[,cla.rif,,mese],breaks=1:26,right=F,freq=T,density=50,angle=45,col=jet.colors.pred[[1]],xlab="WTs Predictors",ylab="Frequency",main=nome.mese[mese]) #,axes=F)
	axis(1,at=1.5:26.5,labels=WTs.names[[1]],cex.axis=1.0,las=2)
	#axis(2,0.05*0:12,las=1)
	}

	# istogramma di frequenza del MBE normalizzato:
	 h<-hist(MBE.norm.best[2,,],breaks=200,right=FALSE,freq=FALSE,density=40,angle=45,col="black",xlab="MBE",xlim=c(-0.15,0.15))
	#plot(h$counts,type="o")

	############### Grafica i valori medi di CV e COR su tutte le serie e i valori medi della Prec.oss e pred. e della dev.standard oss e pred.      #

	 # fa direttamente il grafico dei valori medi su tutte le stazioni del CV sul periodo di calibrazione e di validazione e mostra solo quello:
	mean.1<-mean.2<-array(NA,c(n.classi,12,max.nWT))
	predmax<-rep(10,12) #predmax<-c(10,10,10,0,0,0,0,0,0,10,10,10) # num.max. di predittori per mese da calcolare e mostrare nei grafici

	pdf(paste(dir_root,"/mapas/Comparison.pdf",sep=""),width=10) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
	y.min<-0.1;y.max<-0.9

	for(graf in 1:2){
	par(mfrow=graph.yx);par(oma=c(1,1,3,1));  par(mar=c(2,2,2,2)) # oma controlla il bordo esterno a tutti i grafici, mar i bordi interni tra grafici
	for(mese in int.mesi){

	if(graf==1){
	mean.1[cla,mese,]<-CV.calib.mean[cla,mese,]
	mean.2[cla,mese,]<-CV.valid.mean[cla,mese,]
	} else {
	mean.1[cla,mese,]<-COR.calib.mean[cla,mese,]
	mean.2[cla,mese,]<-COR.valid.mean[cla,mese,]
	}

	print(plot(rep(0,predmax[mese]),type="n",xlab="Num.of predictors used", ylab="CV",ylim=c(y.min,y.max),yaxp=c(y.min,y.max,(y.max-y.min)*10),xaxp=c(0,predmax[mese],predmax[mese]))) # stampa un grafico vuoto con gli assi e basta
	print(lines(mean.1[cla,mese,],type="o",col=col.metodo[1],cex=.6))
	print(lines(mean.2[cla,mese,],type="o",col=col.metodo[2],cex=.6))

	title(nome.mese[mese],line=0.5,cex=1.1)

	qrr<-ifelse(graf==1,"CV","COR")
	leg1<-paste(qrr," for calibration period ",start.regr,"-",end.regr,sep="")
	leg2<-paste(qrr," for validation period ",start.valid,"-",end.valid,sep="")

	legend("bottomright",c(leg1,leg2),col=col.metodo,lwd=.8)
	} # chiude il for sui mesi per il grafico finale

	# titolo grafico finale:
	prr<-ifelse(PCRA,"with PCA","without PCA")
	mtext(paste("Mean ",qrr," for ",n.staz.regr," stations ",prr,sep=""),outer=T,cex=1.2)
	} # chiude il for su graf

	dev.off()

	###### Grafico dei CORRELATION COEFFICIENTS tra Prec e WTs + Mappe ####################################################################

	cc<-array(NA,c(max.nWT,n.classi,n.staz,12),dimnames=list(WTs.names[[1]],nome.classe,listaz,nome.mese))        # coefficienti di correlazione tra la serie di prec.mensile e la serie del WT X per lo stesso periodo.

	barraP<-winProgressBar("Analyzing data","Please wait...",0,n.staz*n.classi*12,0)
	for(mese in 1:12){
		for(cla in cla.rif){
			for(st in 1:n.staz){ # cicla sulla stazione da analizzare
				stat=listaz[st] 

				# copia la matrice monthlyWT in una lista WT solo con la prec del mese scelto e i WT della classificazione e del mese scelto:
				WT<-list()
				WT[[1]]<-subset(dati.regr,dati.regr[[1]]==stat,select=2+mese)[[1]] # seleziona solo le file di prec della stazione che ci interessa
				for(w in 1:nWT[cla])WT[[1+w]]<-subset(monthlyWT.regr[[cla]],monthlyWT.regr[[cla]][,2]==mese,select=2+w) # aggiunge le file con i WT della classificazione scelta
				WT<-as.data.frame(WT);names(WT)=c("prec",1:nWT[cla]) # trasforma tutto in un dataframe per fare la regressione
				#WT

				# correlation coefficient per TUTTI i WT:
				for(p in 1:nWT[cla]) cc[p,cla,st,mese]<-cor(WT[,1],WT[,1+p])

				setWinProgressBar(barraP,st+(cla-1)*n.staz+(mese-1)*n.staz*n.classi)
			} # chiude il for sulle stazioni
		} # chiude il for sulle classificazioni
	} # chiude il for sui mesi
	close(barraP) 

	pearson<-round(cc[,2,,]^2,2) # tabella con l' R2 tra la prec.mensile e i WTs

	my.levels<- c(-1,0,0.2,0.3,0.4,0.5,0.6,0.7,0.8,1) #mostra i dati da -1 a 1
	#my.var30=c("WT1","WT2","WT3","WT4","WT5","WT6","WT7","WT8","WT9","WT10","WT11","WT12","WT13","WT14","WT15","WT16","WT17","WT18","WT19","WT20","WT21","WT22","WT23","WT24","WT25","WT26","WT27","WT28","WT29","WT30")

	 # crea un file .pdf per ogni mese:
	 for(mese in 1:12){
		 pdf(paste(dir_root,"/",nome.mese[mese]," Correlation Coefficients.pdf",sep=""),width=11, height=7) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.

		for(cla in cla.rif){
			# carica i dati di correlazione da disegnare in infofile:
			for(p in 1:nWT[cla]){
				 infofile[[4+p]]<-cc[p,cla,,mese]
				 names(infofile)[4+p]=WTs.names[[1]][p]  #paste("WT",p,sep="")
			}

			my.name=paste(nome.mese[mese]," Correlation Coefficients for Classification num.",cla," (",nome.classe[cla],")",sep="")
			my.var=WTs.names[[1]] #my.var30[1:nWT[cla]]

			# visualizza le mappe in coordinate geografiche o in UTM30: 
			#print(spplot(infofile,my.var,key.space = "right",cuts=my.levels,col.regions=rev(jet.colors(100)),main=my.name,sp.layout=my.layout,cex=0.4,as.table=T))
			print(spplot(infofile,my.var,key.space = "right",cuts=my.levels,col.regions=rev(jet.colors(100)),main=my.name,sp.layout=my.layout,cex=0.4,as.table=T))
			#bubble(df2, "z1", key.space = "bottom") # per rappresentare la variabile visuale con il tama?o invece che con il colore

		 } # chiude il for sulle classificazioni
		 dev.off()
	 } # chiude il for sui mesi	 
} # chiude l'if su altro

#############################################################################################################################
#									    MAPPE RIASSUNTIVE STEPWISE REGRESSION    											#
#############################################################################################################################
my.text<-list("sp.text", c(990000,4000000), "400 km",cex=.5,which=9) # in futuro riadattalo anche per le mappe in corrd.geografiche
my.north.arrow<-list("SpatialPolygonsRescale", offset = c(990000,4030000), scale = 60000,layout.north.arrow(type=2),size=60000,which=9) # per disegnare l'altra freccia del nord meno orribile, quella senza la N dentro la freccia
my.text2<-list("sp.text", c(1000000,4120000), "N",cex=.5,which=9) # which serve per aggiungere il testo solo nel pannello numero 6 !!!
my.scale.bar<-list("SpatialPolygonsRescale", layout.scale.bar(), offset = c(600000,3980000),scale = 300000, which=9,fill=c("transparent","black"))
my.layout.full<-list(my.scale.bar,my.polygon,my.text,my.text2,my.north.arrow)

# crea i dati da mettere nelle mappe riassuntive:

# mappe riassuntive per la classificazione di riferimento: (se si sta facendo l'interpolazione le variabili vanno messe in un grid)
if(interpol=="NO"){
	CV.calib.best.data<-CV.valid.best.data<-COR.calib.best.data<-COR.valid.best.data<-R2.valid.best.data<-rapp.prec.data<-rapp.sd.data<-proportion.data<-COR.valid.best.no.sys.data<-RMSE.valid.best.data<-MBE.valid.best.data<-sd.true.data<-sd.rec.data<-infofile
	n.pred.forw.data<-pred1.forw.data<-pred2.forw.data<-intercept.perc.data<-intercept.data<-prec.obs.data<-SUM.RAIN.WT.data<-SS.CLI.RMSE.data<-CV.valid.best.no.sys.data<-SS.CLI.RMSE.no.sys.data<-infofile
	CV.MAE.data<-d.Willmott.data<-d.Willmott.1.data<-d.Willmott.2011.data<-CV.MBE.data<-infofile
} else {
	CV.calib.best.data<-CV.valid.best.data<-COR.calib.best.data<-COR.valid.best.data<-R2.valid.best.data<-rapp.prec.data<-rapp.sd.data<-proportion.data<-COR.valid.best.no.sys.data<-RMSE.valid.best.data<-MBE.valid.best.data<-sd.true.data<-sd.rec.data<-void.grid
	n.pred.forw.data<-pred1.forw.data<-pred2.forw.data<-intercept.perc.data<-intercept.data<-prec.obs.data<-SUM.RAIN.WT.data<-SS.CLI.RMSE.data<-CV.valid.best.no.sys.data<-SS.CLI.RMSE.no.sys.data<-void.grid
	CV.MAE.data<-d.Willmott.data<-d.Willmott.1.data<-d.Willmott.2011.data<-CV.MBE.data<-void.grid
}

for(mese in int.mesi){
	#CV.calib.best.data@data[[nome.mese.short[mese]]]<-CV.calib.best[cla.rif,,mese]
	 CV.valid.best.data@data[[nome.mese.short[mese]]]<-CV.valid.best[cla.rif,,mese]
	 RMSE.valid.best.data@data[[nome.mese.short[mese]]]<-RMSE.valid.best[cla.rif,,mese]
	 MBE.valid.best.data@data[[nome.mese.short[mese]]]<-MBE.valid.best[cla.rif,,mese]
	 
	 #COR.calib.best.data@data[[nome.mese.short[mese]]]<-COR.calib.best[cla.rif,,mese]
	 COR.valid.best.data@data[[nome.mese.short[mese]]]<-COR.valid.best[cla.rif,,mese]
	 R2.valid.best.data@data[[nome.mese.short[mese]]]<-COR.valid.best[cla.rif,,mese]^2
	 n.pred.forw.data@data[[nome.mese.short[mese]]]<-n.pred.forw[cla.rif,,mese] # indica il numero di predittori per la regressione di tipo forward (esclusa naturalmente l'intercetta)
	 pred1.forw.data@data[[nome.mese.short[mese]]]<-pred.forw[1,cla.rif,,mese] # predittore piu' importante
	 pred2.forw.data@data[[nome.mese.short[mese]]]<-pred.forw[2,cla.rif,,mese] # secondo predittore piu' importante
	 prec.obs.data@data[[nome.mese.short[mese]]]<-media.prec.obs[,mese] # memorizza la precipitazione OSSERVATA per quel mese mediata su tutto il periodo di regressione della stazione
	intercept.data@data[[nome.mese.short[mese]]]<-rep(NA,n.staz.regr)
	st.with.n.pred.not.0<-which(n.pred.forw[cla.rif,,mese]!=0);st.with.n.pred.0<-which(n.pred.forw[cla.rif,,mese]==0)
	temp<-rep(NA,n.staz.regr);for(st in st.with.n.pred.not.0)temp[st]<-coeff.forw.all[n.pred.forw[cla.rif,st,mese],1,cla.rif,st,mese]# memorizza il peso dell'intercetta (se c'e'almeno un predittore!!! Altrimenti memorizza il valor medio della prec.osservata nel periodo)
	intercept.data@data[[nome.mese.short[mese]]]<-temp
	for(st in st.with.n.pred.0)intercept.data@data[[nome.mese.short[mese]]][st]<-media.prec.obs[st,mese]
	intercept.perc.data@data[[nome.mese.short[mese]]]<-intercept.data@data[[nome.mese.short[mese]]]/media.prec.obs[,mese]
	 #rapp.prec.data@data[[nome.mese.short[mese]]]<-prec.rec.mean[cla.rif,,mese]/prec.true.mean[cla.rif,,mese]
	 rapp.sd.data@data[[nome.mese.short[mese]]]<-sd.rec[cla.rif,,mese]/sd.true[cla.rif,,mese]
	 proportion.data@data[[nome.mese.short[mese]]]<-proportion[cla.rif,,mese] # rapporto tra RMSEs e RMSE
	 SS.CLI.RMSE.data@data[[nome.mese.short[mese]]]<-SS.CLI.RMSE[cla.rif,,mese] # coincide con la skill score climatologico del CV
	 CV.valid.best.no.sys.data@data[[nome.mese.short[mese]]]<-CV.valid.best.no.sys[cla.rif,,mese]
	 SS.CLI.RMSE.no.sys.data@data[[nome.mese.short[mese]]]<-SS.CLI.RMSE.no.sys[cla.rif,,mese] # coincide con la skill score climatologico del CV
	 COR.valid.best.no.sys.data@data[[nome.mese.short[mese]]]<-COR.valid.best.no.sys[cla.rif,,mese]
	 CV.MAE.data@data[[nome.mese.short[mese]]]<-CV.MAE[cla.rif,,mese]
	 CV.MBE.data@data[[nome.mese.short[mese]]]<-CV.MBE[cla.rif,,mese]
	 d.Willmott.data@data[[nome.mese.short[mese]]]<-d.Willmott[cla.rif,,mese]
	 d.Willmott.1.data@data[[nome.mese.short[mese]]]<-d.Willmott.1[cla.rif,,mese]
	 d.Willmott.2011.data@data[[nome.mese.short[mese]]]<-d.Willmott.2011[cla.rif,,mese]
 }

# calcolo del contributo mensile assoluto e relativo (%) alla prec.totale di 1 giorno appartenente al WT considerato:
barraP<-winProgressBar("Analyzing WTs","Please wait...",0,nWT[cla.rif],0)
coeff.WT.data<-coeff.WT.abs.data<-degrees.daily.data<-list()
for(wt in 1:nWT[cla.rif]){
	if(interpol=="NO"){coeff.WT.abs.data[[wt]]<-infofile} else {coeff.WT.abs.data[[wt]]<-void.grid}
	coeff.WT.data[[wt]]<-coeff.WT.abs.data[[wt]]
	degrees.daily.data[[wt]]<-coeff.WT.abs.data[[wt]]	
	for(mese in int.mesi){
		 coeff.WT.abs.data[[wt]]@data[[nome.mese.short[mese]]]<-rep(NA,n.staz.regr)
		 wt.pos<-rep(NA,n.staz.regr) 
		 w.ind<-which(pred.forw[,cla.rif,,mese]==wt,arr.ind=T) # matrice con la posizione del predittore wt nella serie i-esima
		 wt.pos[w.ind[,2]]<- w.ind[,1] # vettore con la posizione di wt nella serie i-esima (NA se non compare)
		 wt.NA<-which(is.na(wt.pos))
		 wt.non.NA<-which(!is.na(wt.pos))
		 temp<-rep(NA,n.staz.regr)
		 series.sin.NA<-intersect(series,wt.non.NA) # toglie le serie dove il predittore non compare dal calcolo del coefficiente (dopo assegna a queste serie il valore 0 del coeff.)
		 for(st in series.sin.NA)temp[st]<-coeff.forw.all[n.pred.forw[cla,st,mese],1+wt.pos[st],cla.rif,st,mese]
		 coeff.WT.abs.data[[wt]]@data[[nome.mese.short[mese]]]<-temp
		 coeff.WT.abs.data[[wt]]@data[[nome.mese.short[mese]]][wt.NA]<-0 # imposta a 0 i coefficienti corrispondenti alle serie e ai mesi in cui il tipo di tempo wt non compare
		 if(interpol!="NO")coeff.WT.abs.data[[wt]]@data[[nome.mese.short[mese]]][sea.pixels]<-NA # imposta a NA i pixel di mare per non disegnarli nella mappa
		 coeff.WT.data[[wt]]@data[[nome.mese.short[mese]]]<-coeff.WT.abs.data[[wt]]@data[[nome.mese.short[mese]]]
		 coeff.WT.data[[wt]]@data[[nome.mese.short[mese]]]<-coeff.WT.abs.data[[wt]]@data[[nome.mese.short[mese]]]/media.prec.obs[,mese] # per trasformare il contributo assoluto in contributo relativo espresso in %
		 degrees.daily.data[[wt]]@data[[nome.mese.short[mese]]]<-coeff.WT.abs.data[[wt]]@data[[nome.mese.short[mese]]]*n.days.month[mese]
	} # chiude il for su mese
setWinProgressBar(barraP,wt,label=paste(wt,"/",nWT) )
};close(barraP) 

# il contributo mensile assoluto e relativo al WT considerato (moltiplicando il contributo di 1 giorno per il numero medio mensile di giorni
# con quel WT calcolato sul periodo begin.analisi:end.analisi):
prec.WT.data<-prec.WT.abs.data<-list()
if(interpol=="NO"){SUM.RAIN.WT.abs.data<-infofile} else {SUM.RAIN.WT.abs.data<-void.grid}
if(interpol=="NO"){SUM.RAIN.WT.abs.full.data<-infofile} else {SUM.RAIN.WT.abs.full.data<-void.grid} # somma assoluta della prec dei 26 Wts + intercetta
for(mese in int.mesi){
	 if(interpol=="NO"){prec.WT.abs.data[[mese]]<-infofile} else {prec.WT.abs.data[[mese]]<-void.grid}
	 prec.WT.data[[mese]]<-prec.WT.abs.data[[mese]]
	 for(wt in 1:nWT[cla.rif])prec.WT.abs.data[[mese]]@data[[WTs.names.full[wt]]]<-coeff.WT.abs.data[[wt]]@data[[nome.mese.short[mese]]]*AN.day.mean[cla.rif,wt,mese] # contributo assoluto di ogni WTs E DI OGNI SERIE alla prec.totlae mensile
	 for(wt in 1:nWT[cla.rif])prec.WT.data[[mese]]@data[[WTs.names.full[wt]]]<-coeff.WT.data[[wt]]@data[[nome.mese.short[mese]]]*AN.day.mean[cla.rif,wt,mese] # contributo relativo di ogni WTs E DI OGNI SERIE alla prec.totlae mensile
	 
	 prec.WT.abs.data[[mese]]@data[["I"]]<-intercept.perc.data@data[[nome.mese.short[mese]]] # contributo dato dal termine noto	 
	 prec.WT.data[[mese]]@data[["I"]]<-intercept.perc.data@data[[nome.mese.short[mese]]] # contributo dato dal termine noto
	 
	 temp<-rep(0,n.staz.regr);for(wt in 1:nWT[cla.rif]){temp<-temp+prec.WT.data[[mese]]@data[[WTs.names.full[wt]]]}
	 prec.WT.data[[mese]]@data[["SUM"]]<-temp # contributo dato dalla somma dei WT (senza il termine noto)
	 SUM.RAIN.WT.data@data[[nome.mese.short[mese]]]<-temp # copio lo stesso contributo in questo dataframe che e' organizzato per mesi invece che per WTs in modo da poterlo cartografare
	 
	 temp.abs<-rep(0,n.staz.regr);for(wt in 1:nWT[cla.rif]){temp.abs<-temp.abs+prec.WT.abs.data[[mese]]@data[[WTs.names.full[wt]]]}
	 prec.WT.abs.data[[mese]]@data[["SUM"]]<-temp.abs # contributo dato dalla somma dei valori assoluti di WT (senza il termine noto) (per la temperatura)
	 SUM.RAIN.WT.abs.data@data[[nome.mese.short[mese]]]<-temp # copio lo stesso contributo in questo dataframe che e' organizzato per mesi invece che per WTs in modo da poterlo cartografare
	 SUM.RAIN.WT.abs.full.data@data[[nome.mese.short[mese]]]<-SUM.RAIN.WT.abs.data@data[[nome.mese.short[mese]]]+intercept.data@data[[nome.mese.short[mese]]]
} # chiude il for sui mesi

# # crea anche i coeff.assoluti e i prec.WT.data assoluti
# coeff.WT.abs.data<-list()
# for(wt in 1:nWT[cla.rif]){
	# if(interpol=="NO"){coeff.WT.abs.data[[wt]]<-infofile}else{coeff.WT.abs.data[[wt]]<-void.grid}
	# for(mese in int.mesi){
		# coeff.WT.abs.data[[wt]]@data[[nome.mese.short[mese]]]<-coeff.WT.data[[wt]]@data[[nome.mese.short[mese]]]*media.prec.obs[,mese] 
	# }
# }

# prec.WT.abs.data<-list()
# if(interpol=="NO"){SUM.RAIN.WT.abs.data<-infofile} else {SUM.RAIN.WT.abs.data<-void.grid}
# if(interpol=="NO"){SUM.RAIN.WT.abs.full.data<-infofile} else {SUM.RAIN.WT.abs.full.data<-void.grid} # somma assoluta della prec dei 26 Wts + intercetta
# for(mese in int.mesi){
	 # if(interpol=="NO"){prec.WT.abs.data[[mese]]<-infofile} else {prec.WT.abs.data[[mese]]<-void.grid}
	 # for(wt in 1:nWT[cla.rif])prec.WT.abs.data[[mese]]@data[[WTs.names.full[wt]]]<-coeff.WT.abs.data[[wt]]@data[[nome.mese.short[mese]]]*AN.day.mean[cla.rif,wt,mese] # contributo relativo di ogni WTs E DI OGNI SERIE alla prec.totlae mensile
	 # prec.WT.abs.data[[mese]]@data[["I"]]<-intercept.perc.data@data[[nome.mese.short[mese]]] # contributo dato dal termine noto	 
	 # temp<-rep(0,n.staz.regr);for(wt in 1:nWT[cla.rif]){temp<-temp+prec.WT.abs.data[[mese]]@data[[WTs.names.full[wt]]]}
	 # prec.WT.abs.data[[mese]]@data[["SUM"]]<-temp # contributo dato dalla somma dei WT (senza il termine noto)
	 # SUM.RAIN.WT.abs.data@data[[nome.mese.short[mese]]]<-temp # copio lo stesso contributo in questo dataframe che e' organizzato per mesi invece che per WTs in modo da poterlo cartografare
	 # SUM.RAIN.WT.abs.full.data@data[[nome.mese.short[mese]]]<-SUM.RAIN.WT.abs.data@data[[nome.mese.short[mese]]]+intercept.data@data[[nome.mese.short[mese]]]
# } # chiude il for sui mesi

# come prec.WT.data e prec.WT.abs.data, ma organizzando le liste per WT invece che per mese:
prec.mese.data<-list()
for(wt.num in 1:nWT[cla.rif]){
	 if(interpol=="NO"){prec.mese.data[[wt.num]]<-infofile} else {prec.mese.data[[wt.num]]<-void.grid}
	 for(mese in int.mesi)prec.mese.data[[wt.num]]@data[[nome.mese.short[mese]]]<-prec.WT.data[[mese]]@data[[WTs.names.full[wt.num]]]
}
prec.mese.abs.data<-list()
for(wt.num in 1:nWT[cla.rif]){
	 if(interpol=="NO"){prec.mese.abs.data[[wt.num]]<-infofile} else {prec.mese.abs.data[[wt.num]]<-void.grid}
	 for(mese in int.mesi)prec.mese.abs.data[[wt.num]]@data[[nome.mese.short[mese]]]<-prec.WT.abs.data[[mese]]@data[[WTs.names.full[wt.num]]]
}

# calcolo valori medi mensili su tutte le serie o pixel della penisola Iberica per i seguenti indici:
#CV.calib.best.medio<-rep(NA,12);for(mese in int.mesi)CV.calib.best.medio[mese]=mean(CV.calib.best.data@data[[nome.mese.short[mese]]],na.rm=T) # si sottointende che si riferisca al metodo forward
#COR.calib.best.medio<-rep(NA,12);for(mese in  int.mesi)COR.calib.best.medio[mese]=mean(COR.calib.best.data@data[[nome.mese.short[mese]]],na.rm=T)
CV.valid.best.medio<-rep(NA,12);for(mese in int.mesi)CV.valid.best.medio[mese]=mean(CV.valid.best.data@data[[nome.mese.short[mese]]],na.rm=T) # si sottointende che si riferisca al metodo forward
RMSE.valid.best.medio<-rep(NA,12);for(mese in int.mesi)RMSE.valid.best.medio[mese]=mean(RMSE.valid.best.data@data[[nome.mese.short[mese]]],na.rm=T)
MBE.valid.best.medio<-rep(NA,12);for(mese in int.mesi)MBE.valid.best.medio[mese]=mean(MBE.valid.best.data@data[[nome.mese.short[mese]]],na.rm=T)
COR.valid.best.medio<-rep(NA,12);for(mese in  int.mesi)COR.valid.best.medio[mese]=mean(COR.valid.best.data@data[[nome.mese.short[mese]]],na.rm=T)
n.pred.forw.medio<-rep(NA,12);for(mese in int.mesi){n.pred.forw.medio[mese]=mean(n.pred.forw.data@data[[nome.mese.short[mese]]],na.rm=T)}  
prec.WT.medio<-array(NA,c(12,nWT[cla.rif]),dimnames=list(nome.mese.short[int.mesi],WTs.type))
for(mese in int.mesi){for(wt in 1:nWT[cla.rif])prec.WT.medio[mese,wt]<-mean(prec.WT.data[[mese]]@data[[WTs.names.full[wt]]],na.rm=T)} # ESCLUSO il contributo dell'intercetta
prec.WT.abs.medio<-array(NA,c(12,nWT[cla.rif]),dimnames=list(nome.mese.short[int.mesi],WTs.type))
for(mese in int.mesi){for(wt in 1:nWT[cla.rif])prec.WT.abs.medio[mese,wt]<-mean(prec.WT.abs.data[[mese]]@data[[WTs.names.full[wt]]],na.rm=T)} # ESCLUSO il contributo dell'intercetta
CV.valid.best.no.sys.medio<-rep(NA,12);for(mese in int.mesi)CV.valid.best.no.sys.medio[mese]=mean(CV.valid.best.no.sys.data@data[[nome.mese.short[mese]]],na.rm=T) # si sottointende che si riferisca al metodo forward
COR.valid.best.no.sys.medio<-rep(NA,12);for(mese in int.mesi)COR.valid.best.no.sys.medio[mese]=mean(COR.valid.best.no.sys.data@data[[nome.mese.short[mese]]],na.rm=T) # si sottointende che si riferisca al metodo forward

# TABELLA contributo assoluto estimato alla prec.mensile dato da ogni WT: (coeff.regr x frequenza mensile WT)
# nel caso della temp indica di quanti gradi la climatologia mensuale aumenta o dimin. per effetto di quel WT)
mean.contribute.ct.abs<-c();for(mese in int.mesi)mean.contribute.ct.abs[mese]<-mean(prec.WT.abs.data[[mese]]@data$I,na.rm=T) # contributo mensile del termine noto
#ftable(round(mean.contribute,2))
contrib.abs<-t(round(prec.WT.abs.medio,3)) # arrotonda
contrib2.abs<-rbind(contrib.abs,colSums(abs(contrib.abs)))
contrib3.abs<-rbind(contrib2.abs,round(mean.contribute.ct.abs,3)) # aggiunge una ultima fila con i valori del constant term

# TABELLA contributo relativo estimato alla prec.mensile dato da ogni WT:
#pdf(paste(dir_root,"/mapas/mapas.pdf",sep="")) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
#mean.contribute<-array(NA,c(12,nWT[cla.rif]),dimnames=list(nome.mese,WTs.names[[1]]))
#for(mese in int.mesi){for(wt in 1:nWT[cla.rif]) mean.contribute[mese,wt]<-mean(prec.WT.data[[mese]][[WTs.names.full[wt]]],na.rm=T)}
mean.contribute.ct<-c();for(mese in int.mesi)mean.contribute.ct[mese]<-mean(prec.WT.data[[mese]]@data$I,na.rm=T) # contributo mensile del termine noto
#ftable(round(mean.contribute,2))
contrib<-t(100*round(prec.WT.medio,3)) # arrotonda e trasforma i valori in percentuali
contrib2<-rbind(contrib,colSums(contrib))
contrib3<-rbind(contrib2,100*round(mean.contribute.ct,3)) # aggiunge una ultima fila con i valori del constant term

# tabella = alla precedente, ma con una tabella di contributi per ogni serie (o pixel) differente:
#(cioe' prima di fare il valore medio su tutte le serie) # occhio che il tempo di calcolo e' abbastanza lungo!!!
# contribute<-array(NA,c(n.staz,12,nWT[cla.rif]),dimnames=list(listaz,nome.mese,WTs.names[[1]]))
# for(st in 1:n.staz){
# for(mese in int.mesi){
# for(wt in 1:nWT[cla.rif]){
	# contribute[st,mese,wt]=prec.WT.data[[mese]][[WTs.names[[1]][wt]]][st]
# }}}
### t(round(contribute[1,,],2)) # visualizza la tabella dei contributi della prima serie arrotondatia 2 cifre decimali

# TABELLA % suolo iberico ove il contributo relativo estimato alla prec.mensile dato da un certo WT e' >0% :
area.affected<-array(NA,c(12,nWT[cla.rif]),dimnames=list(nome.mese,WTs.names[[1]]))
for(mese in int.mesi){for(wt in 1:nWT[cla.rif]) {area.affected[mese,wt]=length(which(prec.WT.data[[mese]]@data[[WTs.names.full[wt]]]>0))/length(which(prec.WT.data[[mese]]@data[[WTs.names.full[wt]]]>=0))}}
tab.area<-t(100*round(area.affected,3)) # arrotonda e trasforma i valori in percentuali

# TABELLA % suolo iberico ove il contributo relativo estimato alla prec.mensile dato da un certo WT e' >15% :
area.affected2<-array(NA,c(12,nWT[cla.rif]),dimnames=list(nome.mese,WTs.names[[1]]))
for(mese in int.mesi){for(wt in 1:nWT[cla.rif]) {area.affected2[mese,wt]=length(which(prec.WT.data[[mese]]@data[[WTs.names.full[wt]]]>0.15))/length(which(prec.WT.data[[mese]]@data[[WTs.names.full[wt]]]>=0))}}
tab.area2<-t(100*round(area.affected2,3)) # arrotonda e trasforma i valori in percentuali

# TABELLA % suolo iberico ove il contributo relativo estimato alla prec.mensile dato da un certo WT e' >30% :
area.affected3<-array(NA,c(12,nWT[cla.rif]),dimnames=list(nome.mese,WTs.names[[1]]))
for(mese in int.mesi){for(wt in 1:nWT[cla.rif]) {area.affected3[mese,wt]=length(which(prec.WT.data[[mese]]@data[[WTs.names.full[wt]]]>0.3))/length(which(prec.WT.data[[mese]]@data[[WTs.names.full[wt]]]>=0))}}
tab.area3<-t(100*round(area.affected3,3)) # arrotonda e trasforma i valori in percentuali

# TABELLA % suolo iberico ove il contributo relativo estimato alla prec.mensile dato da un certo WT e' >50% :
area.affected4<-array(NA,c(12,nWT[cla.rif]),dimnames=list(nome.mese,WTs.names[[1]]))
for(mese in int.mesi){for(wt in 1:nWT[cla.rif]) {area.affected4[mese,wt]=length(which(prec.WT.data[[mese]]@data[[WTs.names.full[wt]]]>0.5))/length(which(prec.WT.data[[mese]]@data[[WTs.names.full[wt]]]>=0))}}
tab.area4<-t(100*round(area.affected4,3)) # arrotonda e trasforma i valori in percentuali

# TABELLA Relative Intensity of each WT (cioe' tabla dei valori medi per ogni serie/pixel di coeff.WT.data, che si misura in 1/giorno)
mean.intensity<-array(NA,c(12,nWT[cla.rif]),dimnames=list(nome.mese,WTs.names[[1]]))
for(mese in int.mesi){for(wt in 1:nWT[cla.rif]) {mean.intensity[mese,wt]=mean(coeff.WT.data[[wt]]@data[[nome.mese.short[mese]]],na.rm=T)}}
tab.intensity<-t(100*round(mean.intensity,3)) # arrotonda e trasforma i valori in percentuali

# TABELLA Absolute Intensity of each WT (cioe' tabla dei valori medi per ogni serie/pixel di coeff.WT.data, che si misura in 1/giorno)
mean.abs.intensity<-array(NA,c(12,nWT[cla.rif]),dimnames=list(nome.mese,WTs.names[[1]]))
for(mese in int.mesi){for(wt in 1:nWT[cla.rif]) {mean.abs.intensity[mese,wt]=mean(coeff.WT.abs.data[[wt]]@data[[nome.mese.short[mese]]],na.rm=T)}}
tab.abs.intensity<-t(round(mean.abs.intensity,3)) # arrotonda e trasforma i valori in percentuali
tab.grados<-tab.abs.intensity*n.days.month[int.mesi] # number of grados that a day of that WT increase or remove to the day when it happens


# RIASSUNTO DI TUTTE LE TABELLE PIU'INTERESSANTI:

round(AN.day.mean[cla.rif,,],2) # frequenza di ogni WT (num.di giorni/mese) in base al mese (uguale anche a mean.fr[,c(int.mesi)])
round(AN.mean[cla.rif,,c(int.mesi)],1) # la stessa freq ma espressa come % di giorni al mese
trend[,c(int.mesi)] # trend della frequenza di ogni WT (in num.gg/mese) su tutto il periodo impostato in base al mese
p.val[,c(int.mesi)] # p-value del trend della frequenza di ogni WT (in num.gg/mese)in base al mese
tab.abs.intensity[,c(int.mesi)] # nel caso della temp., indica che UN GIORNO appartenente a quel tipo di tempo aumenta la temperatura media MENSILE di quel valore.
contrib3.abs # (tab.abs.intensity x freq.WT) nel caso della temp, indica di quanti gradi la climatologia mensuale aumenta o dimin. per effetto di quel WT
tab.grados   # spatial mean of regression coefficient for 30-31 (num.days in month). Indica di quanti gradi un giorno di quel WD e`piu`caldo o freddo risp.a media.

tab.intensity[,c(int.mesi)] # media su tutte le serie (o pixel) del coeff.della regr.associato al WT diviso per la prec.media.mensile[calcolata su tutti gli anni della regr] della serie (o pixel) [ogni punto della tabella indica che un giorno di quel WT contribuisce all'1% della prec.relativa {cioe' pesata sul suo valore medio} di tutta la penisola iberica]
contrib3[,c(int.mesi)]  # % Contributo Relativo di ogni WT (= media su tutte le serie (o pixel) della frequenza del WT (gg/mes) * il coeff.regressione dello stesso WT / mean monthly rainfall su tutti gli anni)
tab.area[,c(int.mesi)] # % Area della IP con piogga > 0% per il WT e il mese considerato 
tab.area2[,c(int.mesi)] # % Area della IP con piogga > 15% per il WT e il mese considerato 
tab.area3[,c(int.mesi)] # % Area della IP con piogga > 30% per il WT e il mese considerato 
tab.area4[,c(int.mesi)] # % Area della IP con piogga > 50% per il WT e il mese considerato 
#cbind(round(CV.valid.best.medio,2),round(CV.valid.best.sys.medio,2)) # confronto CV medio mensile con e senza l'errore sistematico
#cbind(round(COR.valid.best.medio,2),round(COR.valid.best.sys.medio,2)) # confronto CV medio mensile con e senza l'errore sistematico

#save.image("C:/nicola/precipitaciones/weather_types/Ip02/Regression_Ip02_mensile_v4_step_min_cv_0,01.RData")
#save.image("C:/nicola/precipitaciones/weather_types/RData/R_session_v154_regr_1861-2005_20th_Century_Project_(Madrid_Valencia_Lisboa).RData")
#save.image("C:/nicola/precipitaciones/weather_types/RData/R_session_v148_como_v118_articolo1_pero_con_D_Willmott_y_MAE_y_MBE.RData")
save.image("C:\\nicola\\temperaturas\\WTs and temp\\stepwise_MOTEDAS_1950-2010_10_WTs_umbral_0,01_absolute_PCA.RData")

# disegna le mappe vere e proprie:
# usa l'opzione interp="no" anche per il dataset MOTEDASP, ma con pch=15 (quadrato invece di cerchio) e cex=.2 invece di .3

my.main="Number of Predictors for each serie and month" 
my.cuts<-seq(0,10,1) #;my.labels=c("0-2","3-4","5-8") # empieza desde -1 so quieres visualizar tambien los pixeles con 0 predictores
#my.cuts<-c(0,0.00001,1,2,3,10) #;my.labels=c("0-2","3-4","5-8")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean=",round(n.pred.forw.medio[int.mesi],1),")",sep="")
if(interpol=="NO"){
my.map<-spplot(n.pred.forw.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.main,sp.layout=my.layout,as.table=T,
	names.attr=my.names[int.mesi],pch=15,cex=.2) #,legendEntries = my.labels)
my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1)# per cambiare il size dei simboli nella legenda!!!
} else { # se stiamo visualizzando un grid, la sola differenza e' che invece di cut dobbiamo usare at per delimitare gli intervalli:
my.map<-spplot(n.pred.forw.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.main,sp.layout=my.layout,cex=0.6,as.table=T,
	names.attr=my.names[int.mesi],colorkey=list(labels=list(at=my.cuts),space="bottom",width=0.6,height=0.6))
};plot(my.map)

my.main<-paste("RMSE for ",nome.classe[cla.rif])
my.cuts<-c(0.5,1.0,1.3,1.6,3);my.labels<-c("0-0.50","0.50-1.00","1.00-1.30","1.30+")  # for temperature
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean CV=",round(CV.best.medio[int.mesi],2),")",sep="")
if(interpol=="NO"){
my.map<-spplot(RMSE.valid.best.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors8),main=my.main,sp.layout=my.layout,as.table=T,
	names.attr = my.names[int.mesi],pch=15,cex=.2)#,legendEntries = my.labels) # as.character(CV.best.levels[-1]))
my.map$legend$right$args$key$points$cex <- rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
}else{# se stiamo visualizzando un grid, la sola differenza e' che invece di cut dobbiamo usare at per delimitare gli intervalli:
my.map<-spplot(RMSE.valid.best.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors8),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],legendEntries = my.labels)	
};plot(my.map)

my.main<-paste("MBE for ",nome.classe[cla.rif])
my.cuts<-c(-1,-0.1,0,0.1,1);my.labels<-c("0-0.50","0.51-0.70","0.71-0.90","0.91+")  # for temperature
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean CV=",round(CV.best.medio[int.mesi],2),")",sep="")
if(interpol=="NO"){
my.map<-spplot(MBE.valid.best.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors8),main=my.main,sp.layout=my.layout,as.table=T,
	names.attr = my.names[int.mesi],pch=15,cex=.2)#,legendEntries = my.labels) # as.character(CV.best.levels[-1]))
my.map$legend$right$args$key$points$cex <- rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
}else{# se stiamo visualizzando un grid, la sola differenza e' che invece di cut dobbiamo usare at per delimitare gli intervalli:
my.map<-spplot(MBE.valid.best.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors8),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],legendEntries = my.labels)	
};plot(my.map)

my.main<-paste("CV(RMSE) for ",nome.classe[cla.rif])
#my.cuts<-c(0,0.5,0.7,0.9,10);my.labels<-c("0-0.50","0.51-0.70","0.71-0.90","0.91+")  # for precipitation
my.cuts<-c(0,0.04,0.07,0.1,1);my.labels<-c("0-0.50","0.51-0.70","0.71-0.90","0.91+")  # for temperature
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean CV=",round(CV.best.medio[int.mesi],2),")",sep="")
if(interpol=="NO"){
my.map<-spplot(CV.valid.best.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors8),main=my.main,sp.layout=my.layout,as.table=T,
	names.attr = my.names[int.mesi],pch=15,cex=.2)#,legendEntries = my.labels) # as.character(CV.best.levels[-1]))
my.map$legend$right$args$key$points$cex <- rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
}else{# se stiamo visualizzando un grid, la sola differenza e' che invece di cut dobbiamo usare at per delimitare gli intervalli:
my.map<-spplot(CV.valid.best.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors8),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],legendEntries = my.labels)	
};plot(my.map)

my.main<-paste("MAE% for ",nome.classe[cla.rif])
my.cuts<-c(0,0.05,0.1,0.2,0.3);my.labels<-c("0-0.50","0.51-0.70","0.71-0.90","0.91+")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean CV=",round(CV.best.medio[int.mesi],2),")",sep="")
CV.MAE.data.bounded<-CV.MAE.data
CV.MAE.data.bounded@data<-as.data.frame(rescale(as.matrix(CV.MAE.data.bounded@data),my.cuts[1],last(my.cuts)))
if(interpol=="NO"){
my.map<-spplot(CV.MAE.data.bounded,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors8),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr = my.names[int.mesi])#,legendEntries = my.labels) # as.character(CV.best.levels[-1]))
my.map$legend$right$args$key$points$cex <- rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
}else{# se stiamo visualizzando un grid, la sola differenza e' che invece di cut dobbiamo usare at per delimitare gli intervalli:
my.map<-spplot(CV.MAE.data.bounded,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors8),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],colorkey=list(labels=list(at=my.cuts),space="bottom",width=0.6,height=0.6))	
};plot(my.map)

my.main<-paste("Index of agreement d for ",nome.classe[cla.rif]);my.cuts<-c(0,0.99,0.994,0.997,1);my.labels<-c("0-0.50","0.51-0.70","0.71-0.90","0.91+")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean CV=",round(CV.best.medio[int.mesi],2),")",sep="")
if(interpol=="NO"){
my.map<-spplot(d.Willmott.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr = my.names[int.mesi])#,legendEntries = my.labels) # as.character(CV.best.levels[-1]))
my.map$legend$right$args$key$points$cex <- rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
}else{# se stiamo visualizzando un grid, la sola differenza e' che invece di cut dobbiamo usare at per delimitare gli intervalli:
my.map<-spplot(d.Willmott.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],legendEntries = my.labels)	
};plot(my.map)

my.main<-paste("Index of agreement d2 for ",nome.classe[cla.rif]);my.cuts<-c(0,0.5,0.6,0.7,1);my.labels<-c("0-0.50","0.51-0.70","0.71-0.90","0.91+")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean CV=",round(CV.best.medio[int.mesi],2),")",sep="")
if(interpol=="NO"){
my.map<-spplot(d.Willmott.1.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr = my.names[int.mesi])#,legendEntries = my.labels) # as.character(CV.best.levels[-1]))
my.map$legend$right$args$key$points$cex <- rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
}else{# se stiamo visualizzando un grid, la sola differenza e' che invece di cut dobbiamo usare at per delimitare gli intervalli:
my.map<-spplot(d.Willmott.1.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],legendEntries = my.labels)	
};plot(my.map)

my.main<-paste("Index of agreement for ",nome.classe[cla.rif]) # la versione del 2011, quella che usiamo di solito
my.cuts<-c(0.40,0.50,0.60,0.70,1);my.labels<-c("-1.00 - 0.40","0.41 - 0.50","0.51 - 0.60","0.61 - 0.70")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean CV=",round(CV.best.medio[int.mesi],2),")",sep="")
d.Willmott.2011.data.bounded<-d.Willmott.2011.data
d.Willmott.2011.data.bounded@data<-as.data.frame(rescale(as.matrix(d.Willmott.2011.data.bounded@data),my.cuts[1],last(my.cuts)))
if(interpol=="NO"){
my.map<-spplot(d.Willmott.2011.data.bounded,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.main,sp.layout=my.layout,as.table=T,legendEntries=my.labels,
	names.attr = my.names[int.mesi],pch=15,cex=.2)#,legendEntries = my.labels) # as.character(CV.best.levels[-1]))
my.map$legend$right$args$key$points$cex <- rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
}else{# se stiamo visualizzando un grid, la sola differenza e' che invece di cut dobbiamo usare at per delimitare gli intervalli:
my.map<-spplot(d.Willmott.2011.data.bounded,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],colorkey=list(labels=list(at=my.cuts),space="bottom",width=0.6,height=0.6))	
};plot(my.map)


my.main<-"Skill Score (CV-based,model:Climatology)"
#my.cuts<-c(-1,0,0.1,0.2,0.3,0.4,0.5,1);# my.labels<-c("0-0.50","0.51-0.70","0.71-0.90","0.91+")
my.cuts<-c(-1,0,0.2,0.4,0.6,1)
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean CV=",round(CV.best.medio[int.mesi],2),")",sep="")
my.map<-spplot(SS.CLI.RMSE.data,nome.mese.short[c(int.mesi)],layout=c(4,3),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors3(1000)),main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,
	names.attr = my.names[int.mesi]) #,legendEntries = my.labels) # as.character(CV.best.levels[-1]))
my.map$legend$right$args$key$points$cex <- rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
plot(my.map)

my.main<-"Skill Score (CV-based,model:Climatology, syst.err.removed)"
#my.cuts<-c(-1,0,0.1,0.2,0.3,0.4,0.5,1);# my.labels<-c("0-0.50","0.51-0.70","0.71-0.90","0.91+")
my.cuts<-c(-2,0,0.2,0.4,0.6,1)
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean CV=",round(CV.best.medio[int.mesi],2),")",sep="")
my.map<-spplot(SS.CLI.RMSE.sys.data,nome.mese.short[c(int.mesi)],layout=c(4,3),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors3(1000)),main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,
	names.attr = my.names[int.mesi]) #,legendEntries = my.labels) # as.character(CV.best.levels[-1]))
my.map$legend$right$args$key$points$cex <- rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
plot(my.map)

my.main=paste("COR for",nome.classe[cla.rif]);my.cuts<-c(0,0.5,0.7,0.9,1);my.labels=c("0-0.50","0.51-0.70","0.71-0.90","0.91-1.00")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  mean=",round(COR.best.medio[int.mesi],2),sep="")
my.map<-spplot(COR.calib.best.data,nome.mese.short[c(int.mesi)],layout=c(2,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr =my.names[int.mesi] ,legendEntries = my.labels) # occhio che pch=19 non gli piace: a volte non disegna p?u' la maggior parte dei punti!!!
my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
plot(my.map)

#my.main=paste("R2 for",nome.classe[cla.rif]);my.cuts<-c(0,0.3,0.5,0.7,1);my.labels=c("0-0.30","0.31-0.50","0.51-0.70","0.71-1.00")
my.main=paste("R2 for",nome.classe[cla.rif]);my.cuts<-c(0,0.25,0.5,0.8,1);my.labels=c("0-0.25","0.26-0.50","0.51-0.80","0.81-1.00")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  mean=",round(COR.best.medio[int.mesi],2),sep="")
my.map<-spplot(R2.valid.best.data,nome.mese.short[c(int.mesi)],layout=c(2,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors4(1000)),sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr =my.names[int.mesi] ,legendEntries = my.labels,main=my.main)
my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
plot(my.map)

my.main="St.Dev.Pred.Prec / St.Dev.Obs.Prec";my.cuts<-c(0,0.5,0.7,0.85,1)
names.attr<-nome.mese
if(interpol=="NO"){
my.map<-spplot(rapp.sd.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi])
my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1)# per cambiare il size dei simboli nella legenda!!!
} else {
#my.map<-
};plot(my.map)

my.main="Normalized Mean Bias Error";my.cuts<-c(-0.1,-0.05,-0.02,-0.01,0.01,0.02,0.05,0.1)
names.attr<-nome.mese
if(interpol=="NO"){
my.map<-spplot(CV.MBE.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=(jet.colors2(1000)),main=my.main,sp.layout=my.layout,as.table=T,
	names.attr=my.names[int.mesi],pch=15,cex=.2)
} else {
#my.map<-
};plot(my.map)

my.main="RMSEs/RMSE";my.cuts<-seq(0,1,0.1)
names.attr<-nome.mese
if(interpol=="NO"){
my.map<-spplot(proportion.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors2(1000)),main=my.main,sp.layout=my.layout,cex=0.5,as.table=T)
} else {
#my.map<-
};plot(my.map)

my.main="Mean Pred.Prec / Mean Obs.Prec"
my.cuts<-c(0,0.5,0.9,0.95,0.98,0.99,0.995,1,005,1.01,1.02,1.05,1.1,2)
my.cuts<-c(0,0.5,0.9,1.1,1.5,10)
names.attr<-nome.mese
if(interpol=="NO"){
my.map<-spplot(rapp.prec.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=(jet.colors2(1000)),main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,
	names.attr=my.names[int.mesi])
} else {
#my.map<-
};plot(my.map)

# mappe coefficienti relativi regressione per ogni WT (= Relative Intensity of each WT, ovvero il contributo relativo in % alla prec.totale dovuto a 1 giorno appartenente al WT considerato)
# (la distribuzione spaziale e' uguale alle mappe dei contributi relativi, ma non si moltiplica per la frequenza mensile dei WT)
for(wt in 1:nWT[cla.rif]){
	my.main<-paste("Relative contribute of 1 day of predictor",WTs.names[[1]][wt]," to total mean monthly precipitation")
	my.cuts<-c(0,0.01,0.1,0.2,0.3,0.5,1);my.labels<-c("0%","<1%","1-10%","11-20%","21-30%","31-50%","51%+")
	my.colors<-c("transparent","#00FFFF","#0099F8","blue","purple")
	#my.cuts<-c(0,0.0001,0.05,0.1,0.15,0.2,0.3,0.5,1); my.colors=c("transparent","darksalmon","darkgoldenrod1","lightgreen","deepskyblue","blue","magenta4","black")
	windows()
	if(interpol=="NO"){
		my.map<-spplot(coeff.WT.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		cuts=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,legendEntries=my.labels)
	} else {
		my.map<-spplot(coeff.WT.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,legendEntries=my.labels)
	}
	plot(my.map)
}

# mappe coefficienti assoluti regressione per ogni WT (= Absolute Intensity of each WT, ovvero il contributo assoluto in mm alla prec.totale dovuto a 1 giorno appartenente al WT considerato)
for(wt in 1:nWT[cla.rif]){
	my.main<-paste("Absolute contribute of 1 day of predictor",WTs.names[[1]][wt])
	if(predictand=="PREC"){
		my.cuts<-c(0,0.01,1,2,10,1000); #my.labels<-c("0 mm","<1 mm","1-10 mm","11-20 mm")
		my.colors<-rev(jet.colors5(1000)) #c("#00FFFF","#0099F8","blue","purple","magenta4","black")
	} else {
		my.cuts<-c(-1,-0.1,-0.01,0,0.01,0.1,1); #my.labels<-c("0 mm","<1 mm","1-10 mm","11-20 mm")
		my.colors<-jet.colors13(1000) #c("#00FFFF","#0099F8","blue","purple","magenta4","black")
	}
	windows()
	if(interpol=="NO"){
		my.map<-spplot(coeff.WT.abs.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		cuts=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T)
	} else {
		my.map<-spplot(coeff.WT.abs.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,legendEntries=my.labels)
	}
	plot(my.map)
}

# mappe gradi in piu/meno rispoetto alla media mensile (la climatologia) associati a UN GIORNO di ogni WT (solo per temperature)
# nota che quando vale zero non vuol dire che la sua influenza sulla temperatura e' nulla, ma che quel tipo di tempo non e' stato selezionato come predittore
for(wt in 1:nWT[cla.rif]){
	my.main<-paste("Temp. shift (with respect to the monthly climatology) for a day with the WT ",WTs.names[[1]][wt])
	my.cuts<-c(-100,-15,-10,-5,-0.000001,0.000001,5,10,15,100); my.labels<-c("< -15?","-15?,-10?","-10?,-5?","-5?,0","no pred.","0?-5?","5?-10?","10-15?","15?+")
	#my.cuts<-c(-100,-15,-10,-5,-1,1,5,10,15,100);
	my.colors<-jet.colors15(1000) #c("#00FFFF","#0099F8","blue","purple","magenta4","black")
	
	jpeg(paste(dir_root,"/composiciones/",WTs.type[wt],".jpg",sep=""),width=590,height=616,quality=100)	
	#windows()
	if(interpol=="NO"){
		my.map<-spplot(degrees.daily.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		cuts=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,pch=15,cex=.3,as.table=T,legendEntries=my.labels)
		my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1)# per cambiare il size dei simboli nella legenda!!!
	} else {
		my.map<-spplot(degrees.daily.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,legendEntries=my.labels)
	}
	plot(my.map)
	dev.off()
}


mese=1;n.imp=6 # numero di WTs da disegnare (in ordine di importanza)
my.main<-paste("Relative contribute to ",nome.mese[mese]," precipitation of the ",n.imp," most influent WTs",sep="") # in ordine di contributo medio piu' alto!!!
my.cuts<-c(0,0.01,0.15,0.3,0.4,0.5);my.labels<-c("","1-15%","16-30%","31-50%","51%+")
my.colors<-c("transparent","#00FFFF","#0099F8","blue","purple")
prec.WT.data.bounded<-prec.WT.data
for(mes in 1:12)prec.WT.data.bounded[[mes]]@data<-as.data.frame(rescale(as.matrix(prec.WT.data.bounded[[mes]]@data),my.cuts[1],last(my.cuts)))
maxWTs<-order(-prec.WT.medio[mese,])[1:n.imp] # ordina i WT in ordine decrescente di contributo relativo e poi prende solo i primi <n.imp> WTs col contributo piu' alto
my.index<-WTs.names.full[maxWTs];my.names=paste(WTs.names.long[maxWTs],"   ",round(100*prec.WT.medio[mese,maxWTs],1),"%",sep="")
if(interpol=="NO"){
my.map<-spplot(prec.WT.data.bounded[[mese]],my.index,layout=c(3,2),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,names.attr=my.names,legendEntries=my.labels)
	#auto.key=list(space="right",title="pippo",text=my.labels,points=list(pch=21,fill=my.colors))) # purtroppo points non funziona!!!
my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1)  # per cambiare il size dei simboli nella legenda!!!
} else {
my.map<-spplot(prec.WT.data.bounded[[mese]],my.index,layout=c(3,2),par.settings = standard.theme(color = FALSE),
	at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,names.attr=my.names,
	colorkey=list(labels=list(at=my.cuts),space="right",width=0.5,height=1))
};plot(my.map)

# mappe WTs mensili 3x3 in ordine di direzione da NW a SE:
mese=6
my.index<-WTs.short.names1 # metti 2 per i tipi ciclonici, 3 per i tipi anticiclonici e 4 per vedere il termine costante al centro invece del termine ciclonico puro
my.names<-WTs.full.names1 # idem come sopra
my.main<-paste("Relative contribute of WTs to total ",nome.mese[mese]," precipitation",sep="")
my.cuts<-c(0,0.01,0.15,0.3,0.5,1);my.labels<-c("","1-15%","16-30%","31-50%","51%+")
my.colors<-c("transparent","#00FFFF","#0099F8","blue","purple")
if(interpol=="NO"){
my.map<-spplot(prec.WT.data[[mese]],my.index,layout=c(3,3),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,names.attr=my.names,legendEntries=my.labels)
my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1)  # per cambiare il size dei simboli nella legenda!!!
} else {
my.map<-spplot(prec.WT.data[[mese]],my.index,layout=c(3,3),par.settings = standard.theme(color = FALSE),colorkey=list(space = "right"),
	at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,names.attr=my.names,legendEntries=my.labels)
}
plot(my.map)

my.main<-"WTs Relative Contribute (%) to total Observed Precipitation";
my.cuts<-c(0,0.5,0.7,0.9,1);my.labels<-c("0-50%","51-70%","71-90%","91-100%");my.colors<-jet.colors8
SUM.RAIN.WT.data.bounded<-SUM.RAIN.WT.data
SUM.RAIN.WT.data.bounded@data<-as.data.frame(rescale(as.matrix(SUM.RAIN.WT.data.bounded@data),my.cuts[1],last(my.cuts)))
if(interpol=="NO"){
my.map<-spplot(SUM.RAIN.WT.data.bounded,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,names.attr=nome.mese[int.mesi],legendEntries=my.labels)
my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
} else { # se stiamo visualizzando un grid, la differenza e' che invece di cut dobbiamo usare at per delimitare gli intervalli e colorkey per mettere la legenda in basso:
my.map<-spplot(SUM.RAIN.WT.data.bounded,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),
	at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,names.attr=nome.mese[int.mesi],
	colorkey=list(labels=list(at=my.cuts),space="bottom",width=0.6,height=0.6))
};plot(my.map)

my.main<-"WTs total Contribute to Observed Precipitation"; # ovvero la climatologia dei WTs, senza la costante
my.cuts<-c(seq(0,300,20),350,400,500);my.colors<-jet.colors8
if(interpol=="NO"){
my.map<-spplot(SUM.RAIN.WT.abs.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,names.attr=nome.mese[int.mesi],legendEntries=my.labels)
my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
} else { # se stiamo visualizzando un grid, la differenza e' che invece di cut dobbiamo usare at per delimitare gli intervalli e colorkey per mettere la legenda in basso:
my.map<-spplot(SUM.RAIN.WT.abs.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),colorkey=list(space = "bottom"),
	at=my.cuts,col.regions=rev(jet.colors(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,names.attr=nome.mese[int.mesi],legendEntries=my.labels)
};plot(my.map)

my.main<-"WTs total Contribute to Observed Precipitation"; # ovvero la climatologia dei WTs, CON la costante
my.cuts<-c(seq(0,300,20),350,400,500);my.colors<-jet.colors8
if(interpol=="NO"){
my.map<-spplot(SUM.RAIN.WT.abs.full.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	cuts=my.cuts,col.regions=rev(jet.colors(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,names.attr=nome.mese[int.mesi],legendEntries=my.labels)
my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1) # per cambiare il size dei simboli nella legenda!!!
} else { # se stiamo visualizzando un grid, la differenza e' che invece di cut dobbiamo usare at per delimitare gli intervalli e colorkey per mettere la legenda in basso:
my.map<-spplot(SUM.RAIN.WT.abs.full.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),colorkey=list(space = "bottom"),
	at=my.cuts,col.regions=rev(jet.colors(1000)),main=my.main,sp.layout=my.layout,cex=0.3,as.table=T,names.attr=nome.mese[int.mesi],legendEntries=my.labels)
};plot(my.map)


### visualizza tutte le sue mappe mensili di un WT a scelta in una composizione 4x4 con al centro il patron dei campi di pressione associati al WT:
datos.SLP<-read.table(file.SLP,header=FALSE,stringsAsFactors=FALSE,na.strings="-999") # database pressione giornaliera nel formato anno/mese/giorno/valori di pressione dei pixel in colonne
datos.SLP<-subset(datos.SLP,datos.SLP[,1]>=begin.analisi & datos.SLP[,1]<=end.analisi) # toglie gli anni fuori dal periodo scelto per l'analisi
listaWT.used<-listaWT[[cla.rif]]
listaWT.used<-subset(listaWT[[cla.rif]],listaWT[[cla.rif]][[1]] >=begin.analisi & listaWT[[cla.rif]][[1]] <=end.analisi)
WorldPoly<- readShapePoly('C:/Projecto_Master/Limites Mundo/TM_WORLD_BORDERS-0.2.shp')
proj4string(WorldPoly) <- CRS("+proj=longlat")
my.polygon=list('sp.polygons',WorldPoly,first=F)
my.layout=list(my.polygon) 
npx.ori<-dim(datos.SLP)[2]-3
gt = GridTopology(cellcentre.offset = angolo.basso.sinistra, cellsize = c(deg,deg), cells.dim = c(npx.ori, npx.ver)) 
grd = SpatialGrid(gt)
proj4string(grd) <- CRS("+proj=longlat +datum=WGS84")

my.names<-nome.mese
my.cuts<-c(0,0.01,0.15,0.3,0.5,1)
#my.cuts<-c(0.1,3,10,20,100)^(1/3)
my.labels<-c("1%","15%","30%","50%","100%")
#my.labels<-c("1 mm","3%","10%","20%","100%")
my.cuts.in.leyend<-c(0.01,0.15,0.30,0.50,1)
my.colors<-c("transparent","#00FFFF","#0099F8","blue","purple")

for(wt in WTs.type){ # cicla su tutti i WTs
	#es: wt="NE" # scegli il tipo di tempo da mappare se non fai il ciclo for
	wt.num<-which(WTs.type==wt) # converte il wt espresso come lettera in numero da 1 a 26
	my.title<-paste("Relative contribute of WT: ",wt," to total monthly precipitation",sep="") # non usato
	my.map<-list()

	if(interpol=="NO"){ # occhio che in questo caso non l'ho ancora verificato!!!
		my.map<-spplot(prec.mese.data[[wt.num]],nome.mese.short[mese],par.settings = standard.theme(color = FALSE),key.space = "right",
			cuts=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,names.attr=my.names,legendEntries=my.labels)
		my.map$legend$right$args$key$points$cex <-rep(1,length(my.cuts)-1)  # per cambiare il size dei simboli nella legenda!!!
	} else {
		for(mese in int.mesi){
			#my.main<-list(label=paste(nome.mese[mese]," ",round(prec.WT.medio[mese,wt.num]*100,1),"%",sep=""),cex=1)
			my.main<-list(label=nome.mese[mese],cex=1)
			my.map[[mese]]<-spplot(prec.mese.data[[wt.num]],nome.mese.short[mese],main=my.main,par.settings = standard.theme(color = FALSE),
				at=my.cuts,col.regions=my.colors,sp.layout=my.layout,cex=.5,names.attr=my.names[mese],legendEntries=my.labels,colorkey=F)
		}
	}

	# sotto la mappa di agosto aggiunge la legenda:
	mese=8;my.main<-list(label=nome.mese[mese],cex=1)
	my.map[[mese]]<-spplot(prec.mese.data[[wt.num]],nome.mese.short[mese],main=my.main,par.settings = standard.theme(color = FALSE),
		at=my.cuts,col.regions=my.colors,sp.layout=my.layout,cex=.5,names.attr=my.names[mese],colorkey=list(space="bottom",width=0.4,height=3,labels=list(at=my.cuts.in.leyend,labels=my.labels)))
			
	# tabella con le variabili da gennaio a dicembre:
	#tab.lateral<-data.frame(cbind("Precipit."=contrib[wt.num,],"Frequency"=round(AN.mean[cla.rif,wt.num,],1),"Intensity"=tab.intensity[WTs.type[wt.num],],
	#			"Area IP"=tab.area[WTs.type[wt.num],],"Area.15"=tab.area2[WTs.type[wt.num],],"Area.30"=tab.area3[WTs.type[wt.num],],
	#			"Area.50"=tab.area4[WTs.type[wt.num],]),row.names=nome.mese.short)
	tab.lateral<-t(data.frame(cbind("Precipitation"=contrib[wt.num,],"Frequency"=round(AN.mean[cla.rif,wt.num,],1),
				"Area"=tab.area[WTs.type[wt.num],]),row.names=nome.mese.short))
				
	# usa la classificazione dei WT giornalieri scelta all'inizio e i campi di pressione giornalieri del database file.SLP (in formato standard) da cui
	# si e' eseguito il downscaling della classificazione in uso e li converte in mappe di pressione media associata ad ogni WT in tutta l'area di studio del database di pressione:
	datos.SLP2<-datos.SLP
	datos.SLP2$WT<-rep(listaWT.used[[4]],each=npx.ver) # aggiunge a destra di datos.SLP2 una colonna con il tipo di tempo corrispondente

	pressure.WT.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,npx.ori*npx.ver)), proj4string = CRS("+proj=longlat +datum=WGS84"))

	datos.temp<-datos.SLP2
	datos.temp<-subset(datos.temp,datos.temp$WT==idWT[[cla.rif]][wt.num])
	n.dias<-dim(datos.temp)[1]/npx.ver
	mean.pressure<-data.frame(array(0,c(npx.ver,npx.ori)))
	for(d in 1:n.dias){
		mean.pressure<-mean.pressure+datos.temp[(npx.ver*(d-1)+1):(npx.ver*d),4:(3+npx.ori)]
	}
	mean.pressure<-mean.pressure/n.dias # per calcolare la media invece de la somma
	# carica i dati di tutte le medie possibili in pressure.grid:
	pressure.WT.grid@data[[WTs.type[wt.num]]]=as.numeric(t(mean.pressure))

	# campi di pressione senza grid colorato sotto ma solo con linee di livello blu:
	#spplot(pressure.WT.grid,wt,sp.layout=list(my.polygon,list("sp.lines",res)),contour=TRUE,col='blue',labels=F,region=F,
	#			main=my.main,xlim=c(-20,10),ylim=c(30,50)) # mappa campi di pressione del WT considerato
	# campi di pressione con grid rosso e blu e linee di livello bianche:
	my.main=list(label=WTs.names.long[wt.num],cex=1.1)
	my.WT.map<-spplot(pressure.WT.grid,wt,sp.layout=my.layout,contour=TRUE,col='gray',region=FALSE,labels=FALSE,
				cuts=30,lwd=1.5,col.regions=rev(jet.colors(1000)),main=my.main,xlim=c(-35,25),ylim=c(25,60)) # colorkey=list(space = "bottom"),cuts=30,
	# campi di pressione con grid rosa bianco azzurro e linee di livello grigio:
	# my.WT.map<-spplot(pressure.WT.grid,wt,sp.layout=my.layout,contour=TRUE,col='gray',labels=F,
	#			colorkey=list(space = "bottom"),main=my.main,xlim=c(-20,10),ylim=c(30,50)) # mappa campi di pressione del WT considerato

	
	# salva tutte le composizioni per ogni WT:
	#jpeg(paste(dir_root,"/mapas/composiciones_EMULATE_small_table/",wt,".jpg",sep=""),width=590,height=616,quality=100) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
	jpeg(paste(dir_root,"/composiciones/",wt,".jpg",sep=""),width=590,height=616,quality=100)

	#windows(width=7, height=9)
	lx=0.25 # lunghezza orizzontale di un mapa piccolo
	ly=0.25 # lunghezza verticale di un mapa piccolo
	g1=0.74 # altezza prima fila
	g3=0.53  # altezza seconda fila
	g8=0.32 # altezza terza fila
	g5=0.11 # altezza quarta fila
	#textplot(as.matrix(tab.lateral),cex=1,halign="center",valign="bottom",mar=c(0,0,0,0),cmar=1)
	textplot(WTs.type[wt.num],cex=7,halign="center",valign="center",mar=c(0,0,0,0))
	
	print(my.map[[1]], position= c(0,g1,0+lx,g1+ly),more=T) # fai ?print.trellis per la spiegazione di come dividere lo schermo con gli spplot
	print(my.map[[2]], position= c(0.25,g1,0.25+lx,g1+ly),more=T) # (xmin, ymin, xmax, ymax)
	print(my.map[[3]], position= c(0.50,g1,0.50+lx,g1+ly),more=T) 
	print(my.map[[4]], position= c(0.75,g1,0.75+lx,g1+ly),more=T) 
	print(my.map[[5]], position= c(0.75,g3,0.75+lx,g3+ly),more=T)
	print(my.map[[6]], position= c(0.75,g8,0.75+lx,g8+ly),more=T)
	print(my.map[[7]], position= c(0.75,g5,0.75+lx,g5+ly),more=T) 
	print(my.map[[8]], position= c(0.50,g5-0.037,0.50+lx,g5+ly),more=T)
	print(my.map[[9]], position= c(0.25,g5,0.25+lx,g5+ly),more=T)
	print(my.map[[10]], position= c(0,g5,0+lx,g5+ly),more=T) 
	print(my.map[[11]], position= c(0,g8,0+lx,g8+ly),more=T)
	print(my.map[[12]], position= c(0,g3,0+lx,g3+ly))
	#print(my.WT.map,position = c(0.25,0.35,0.75,0.93),more=T)

	#or=4;ve=5 # numero di riquadri in orizzontale e in verticale per mettere le mappe
	# print(my.map[[1]], split= c(1,1,or,ve),more=T) # fai ?print.trellis per la spiegazione di come dividere lo schermo con gli spplot
	# print(my.map[[2]], split= c(2,1,or,ve),more=T)
	dev.off()
	
} # chiude il for sul WT mappato


#save.image(paste(dir_root,"/RData/R_session_v133_por_pixels_Composicion_EMULATE_corregido_before_regr.RData",sep=""))

# altre mappe:
if(PCRA==F){nombre="WT"} else {nombre="PC"}
cla.levels<-seq(0,n.classi,1)
cla.name="Best classification for each station and month"
regr.levels<-c(0,1,2)
#regr.name="Best stepwise method for each station and month \n (blue: forward; red: backward)"
regr.name="Best stepwise method for each station and month"
pred1.name<-paste("Most important",nombre,"of ",nome.classe[cla.rif])
pred2.name<-paste("2nd Most important",nombre,"of ",nome.classe[cla.rif])
pred1.levels<-seq(0,nWT[cla.rif])
COR.name="COR of the best classification for each station and month";COR.levels<- c(0,0.25,seq(0.3,1,0.05))
prec.obs.name<-"Observed Mean Monthly Precipitation during Regression period";prec.levels<-c(seq(0,300,50),1000)
intercept.name<-"Regression Constant Term";intercept.levels<-c(seq(0,100,5),150)
intercept.perc.name<-"Relative contribute of Constant Term to total precipitation";intercept.perc.levels<-prec.levels

print(spplot(prec.obs.data,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",cuts=prec.levels,col.regions=rev(jet.colors2(1000)),main=prec.obs.name,sp.layout=my.layout,cex=0.5,as.table=T))
print(spplot(pred1.forw.data,nome.mese.short[int.mesi],layout=c(3,2),par.settings = standard.theme(color = FALSE),key.space = "right",checkEmptyRC=F,identify=F,cuts=pred1.levels,col.regions=jet.colors.pred[[cla.rif]],main=pred1.name,sp.layout=my.layout,pch=20,cex=0.7,as.table=T,legendEntries=WTs.names[[cla.rif]]))
print(spplot(pred2.forw.data,nome.mese.short[c(int.mesi)],layout=c(3,2),par.settings = standard.theme(color = FALSE),key.space = "right",cuts=pred1.levels,col.regions=jet.colors.pred[[cla.rif]],main=pred2.name,sp.layout=my.layout,pch=20,cex=0.7,as.table=T,legendEntries=WTs.names[[cla.rif]])) 
spplot(intercept.data,nome.mese.short[c(int.mesi)],layout=c(2,4),par.settings = standard.theme(color = FALSE),key.space = "right",at=intercept.levels,col.regions=rev(jet.colors2(1000)),main=intercept.name,sp.layout=my.layout,pch=19,cex=0.5,as.table=T)
print(spplot(intercept.perc.data,nome.mese.short[c(int.mesi)],layout=c(,2),par.settings = standard.theme(color = FALSE),key.space = "right",cuts=intercept.perc.levels,col.regions=prec.perc.colors,main=intercept.perc.name,sp.layout=my.layout,pch=19,cex=0.5,as.table=T))


# parametri interessanti di spplot:
# par.settings = list(axis.line = list(col = 'transparent')) per togliere i bordi ai grafici (ma non ai titoli)
# par.settings = c(standard.theme(color = FALSE), list(par.xlab.text = list(cex = 5, col = "blue"))) per cambiare il colore del box dei titoli (o toglierlo mettendo 'transparent')
# names.attr<-c("...","...", ... ) per cambiare i nomi dentro i titoli rosa dei grafici
}

if(interpol!="NO"){################ MONTHLY PRECIPITATION GRID DELLE VARIABILI PUNTUALI CALCOLATE #############################################################################
# devi solo impostare qui sotto la VARIABILE da interpolare in infofile:
# carica i dati dei valori mensili della variabile scelta in infofile in base all'anno considerato (o direttamente tutta la climatologia se interpol="CLI"):
for(mese in int.mesi)infofile[[nome.mese.short[mese]]]<-n.pred.forw[cla.rif,,mese] #ATTENZIONE: non ci devono essere mesi con valori di manca-dato della variabile (es: -999); solo NA va bene!
# for(mese in int.mesi)infofile[[nome.mese.short[mese]]]<-SUM.RAIN.WT.abs.data[[nome.mese.short[mese]]] #ATTENZIONE: non ci devono essere mesi con valori di manca-dato della variabile (es: -999); solo NA va bene!
# for(mese in int.mesi)infofile[[nome.mese.short[mese]]]<-MBE.norm.data[[nome.mese.short[mese]]] #ATTENZIONE: non ci devono essere mesi con valori di manca-dato della variabile (es: -999); solo NA va bene!
# for(mese in int.mesi)infofile[[nome.mese.short[mese]]]<-proportion.data[[nome.mese.short[mese]]] #ATTENZIONE: non ci devono essere mesi con valori di manca-dato della variabile (es: -999); solo NA va bene!
# wt="A";for(mese in int.mesi)infofile[[nome.mese.short[mese]]]<-prec.WT.abs.data[[mese]][[wt]] # in questo caso devi anche selezionare un WT
#for(mese in int.mesi)infofile[[nome.mese.short[mese]]]<-CV.MAE.data[[nome.mese.short[mese]]] #ATTENZIONE: non ci devono essere mesi con valori di manca-dato della variabile (es: -999); solo NA va bene!
#for(mese in int.mesi)infofile[[nome.mese.short[mese]]]<-d.Willmott.2011.data[[nome.mese.short[mese]]] #ATTENZIONE: non ci devono essere mesi con valori di manca-dato della variabile (es: -999); solo NA va bene!

n.dec=3 # numero di decimali della variabile scelta al termine della interpolazione

 # cerca se ci sono 2 o + serie che hanno le stesse coordinate; in questi casi, le sposta di un metro piu' a nord in modo che si possa fare il kriging:
if(dim(zerodist(infofile))[1]>0)print(paste("Trovate",dim(zerodist(infofile))[1],"serie coincidenti che sono state spostate un poco piu' a nord"))
lonlat<-infofile@coords # stringa con la long+lat di ogni stazione # equivalentemente: lonlat<-paste(coordinates(infofile)[,1],coordinates(infofile)[,2])
nlonlat<-dim(lonlat)[1]
if(proyected==FALSE){small.shift<-0.00001}else{small.shift<-1}
#n.coinc<-0
for(st in 1:nlonlat){
	   ss<-which(lonlat[,1]==lonlat[st,1] & lonlat[,2]==lonlat[st,2]) # vettore con tutte le righe della tabla che hanno la stessa lon e lat della riga staz (dovrebbe esserci 1 sola fila)
	   nss<-length(ss) # se vale 1 vuol dire che va bene
	   if(nss>1){
		#print(paste(st,listaz[st],ss[1],ss[2])) # riga per il debug; normalmente ci sono 2 stazioni nella stessa posizione
		for(k in 2:nss)infofile@coords[ss[k],2]=infofile@coords[ss[k],2]+small.shift*k-1 # aumenta di k centomillesimi di grado o di k metri la latitudine (esclusa la prima stazione del gruppo)
		#n.coinc<-n.coinc+1 #print(n.coinc)
	   }  
  }
   
 pixel.size=10
  
# crea un generico grid a <pixel.size> km in UTM30 che si sovrapponga a tutta la Penisola Iberica:
gt = GridTopology(cellcentre.offset = c(-70000, 3980000), cellsize = c(1000*pixel.size,1000*pixel.size), cells.dim = c(ceiling(1110/pixel.size), ceiling(890/pixel.size))) 
grd = SpatialGrid(gt)
n.pixels<-grd@grid@cells.dim[1]*grd@grid@cells.dim[2]
proj4string(grd) <- CRS("+proj=utm +zone=30 +datum=WGS84") # +ellps=clrk66")
#summary(grd);plot(IpPoly);plot(grd,add=T) # visualizza il grid sovrapposto alla IP

# crea un grid vuoto (Var.grid) dove mettere i risultati dell'interpolazione per la variabili in esame
Var.grid<-void.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,n.pixels)), proj4string = CRS("+proj=utm +zone=30 +datum=WGS84"))

# interpola i mesi dell'anno selezionati
# mette il risultato in Var,grid ed arrotonda la precipitazione prevista alla X-esima cifra decimale per non occupare troppo spazio se poi la si salva su un .txt (tanto l'errore introdotto arrotondando e' trascurabile)::
formul<-c(Jan~1,Feb~1,Mar~1,Apr~1,May~1,Jun~1,Jul~1,Aug~1,Sep~1,Oct~1,Nov~1,Dec~1)
for(mese in int.mesi){ 
	print(paste("Mese:",mese)) # cosi' se avvisa che il variogram e' un singular model sai a che mese e anno si riferisce
	v <- variogram(formul[[mese]], infofile)
	#plot(v,type='b') # per vedere i punti del semivariogramma, type=b traccia anche una linea spezzata tra i punti, ma non e' il fit
	#v.fit <- fit.variogram(v, model=vgm(psill=8000, model='Gau', range=200000, nugget=500)) # calcola automaticamente tutti i parametri della curva di fit, basta dargli dei valori iniziali approssimativi!!!!!
	temp.nugget<-v$gamma[1] 		# valore inziale del nugget per fare una prova, dopodiche l'algoritmo di fit.variogram aggiusta i valori
	temp.sill<-last(v$gamma)	# come valori iniziali ho messo quelli che si possono ricavare 'ad occhio' dal variogramma sperimentale v
	temp.range<-last(v$dist)
	v.fit <- fit.variogram(v, model=vgm(psill=temp.sill-temp.nugget, model='Sph', range=temp.range, nugget=temp.nugget))
	
	#v.fit #per vedere i parametri risultato del fit
	print(plot(v,v.fit)) # per vedere il semivariogramma + la curva di fit #b <- mean(DistData[[i]][[j+1]]) # solo per il simple kriging
	#Prec.grid@data[[mese]]<-round(krige(formula=formul[[mese]], locations=infofile.sinNA, newdata=grd, model=v.fit,nmax=int.nmax)@data$var1.pred,1) # se desse problemi a fare il kriging prova a vedere se dipende da una cattiva curva del fit, prova magari a impostare un range del fit piu' corto.
	Var.grid@data[[nome.mese.short[mese]]]<-round(krige(formula=formul[[mese]], locations=infofile,na.action=na.omit, newdata=grd, model=v.fit,nmax=int.nmax)@data$var1.pred,n.dec) # come prima ma permette di considerare anche input con osservatori senza dati (NA) perche' li esclude dall'interpolazione!!! (con na.omit)
}

# seleziona i pixel di mare con overlay e li mette a NA in modo che non li disegni nella mappa finale:
sea.pixels<-which(is.na(overlay(grd,IpPoly))==T)
land.pixels<-(1:n.pixels)[-sea.pixels]
for(mese in 1:12)Var.grid@data[[nome.mese.short[mese]]][sea.pixels]=NA

# (fine interpolazione)

# disegna il grid della variabile scelta:

my.name="CV(RMSE)" ;my.cuts<-c(0,0.5,0.7,0.9,10);my.labels<-c("0-0.50","0.51-0.70","0.71-0.90","0.91+")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean=",round(n.pred.forw.medio[int.mesi],1),")",sep="")
spplot(Var.grid,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors8),main=my.name,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],legendEntries = my.labels)	

int.mesi=c(10:12,1:5)
my.name="CV(MAE)" ;my.cuts<-c(0,0.05,0.10,0.15,1);my.labels<-c("0-5%","6-10%","11-15%",">16%")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean=",round(n.pred.forw.medio[int.mesi],1),")",sep="")
spplot(Var.grid,nome.mese.short[c(int.mesi)],layout=c(2,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors8),main=my.name,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],legendEntries = my.labels)	
	
my.name="d of Willmott definition 1" ;my.cuts<-c(0,0.99,0.994,0.997,1); #my.labels<-c("0-5%","6-10%","11-15%",">16%")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean=",round(n.pred.forw.medio[int.mesi],1),")",sep="")
spplot(Var.grid,nome.mese.short[c(int.mesi)],layout=c(2,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=jet.colors8,main=my.name,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi]) #,legendEntries = my.labels)	

my.name="d of Willmott definition 2" ;my.cuts<-c(0,0.5,0.6,0.7,1); #my.labels<-c("0-5%","6-10%","11-15%",">16%")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean=",round(n.pred.forw.medio[int.mesi],1),")",sep="")
spplot(Var.grid,nome.mese.short[c(int.mesi)],layout=c(2,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=jet.colors8,main=my.name,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi]) #,legendEntries = my.labels)	

my.name="d of Willmott definition 3" ;my.cuts<-c(-1,0.56,0.64,0.72,1); #my.labels<-c("0-5%","6-10%","11-15%",">16%")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean=",round(n.pred.forw.medio[int.mesi],1),")",sep="")
spplot(Var.grid,nome.mese.short[c(int.mesi)],layout=c(2,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=jet.colors8,main=my.name,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi]) #,legendEntries = my.labels)	
	
my.name="R2" ;my.cuts<-c(0,0.3,0.5,0.7,1);my.labels=c("0-0.30","0.31-0.50","0.51-0.70","0.71-1.00")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean=",round(n.pred.forw.medio[int.mesi],1),")",sep="")
spplot(Var.grid,nome.mese.short[c(int.mesi)],layout=c(2,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.name,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],legendEntries = my.labels)	

my.name="RMSEs/RMSEn" ;my.cuts<-c(0,0.5,0.7,0.8,0.9,1.0) #;my.labels=c("0-2","3-5","6-8")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean=",round(n.pred.forw.medio[int.mesi],1),")",sep="")
spplot(Var.grid,nome.mese.short[c(int.mesi)],layout=c(3,3),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.name,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],legendEntries = my.labels)	

my.name="Desv.stand prev / obs" ;my.cuts<-c(0,0.5,0.7,0.8,0.9,1.1) #;my.labels=c("0-2","3-5","6-8")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean=",round(n.pred.forw.medio[int.mesi],1),")",sep="")
spplot(Var.grid,nome.mese.short[c(int.mesi)],layout=c(3,3),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.name,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],legendEntries = my.labels)	
	
my.name="Number of Predictors for each serie and month" ;my.cuts<-seq(0,10);my.labels=c("0-2","3-5","6-8")
my.names<-nome.mese #paste(nome.mese.short[int.mesi],"  (mean=",round(n.pred.forw.medio[int.mesi],1),")",sep="")

spplot(Var.grid,nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
	at=my.cuts,col.regions=rev(jet.colors4(1000)),main=my.name,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,
	names.attr=my.names[int.mesi],legendEntries = my.labels)	

my.main<-"WTs Relative Contribute to Observed Precipitation";
my.cuts<-c(0,0.3,0.4,0.5,0.6,0.7,0.8,0.9,5);my.labels<-c("0-30%","41-50","41-50","51-70%","61-70%","71-80%","81-90%","91-100%")
my.palette<-colorRampPalette(c("red","yellow","cyan","blue"))
my.colors<-my.palette(1000)
spplot(Var.grid,nome.mese.short[c(int.mesi)],layout=c(2,4),par.settings = standard.theme(color = FALSE),colorkey=list(space = "right"),
	at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,names.attr=nome.mese[int.mesi],legendEntries=my.labels)

my.main<-"WTs Predicted Climatology without constant term";
my.cuts<-c(seq(0,50,1),seq(52.5,150,2.5),seq(155,200,5),seq(210,290,20),400);#my.labels<-c("0-30%","41-50","41-50","51-70%","61-70%","71-80%","81-90%","91-100%")
my.prec.levels.in.leyend<-c(0,25,50,75,100,150,200,250,300,350,400)
jet.colors.clim <-colorRampPalette(c("violet","blue", "#007FFF", "cyan","#7FFF7F", "yellow", "#FF7F00", "red", "#7F0000"))
my.palette<-jet.colors.clim
my.colors<-rev(my.palette(1000))
spplot(Var.grid,nome.mese.short[1:12],layout=c(3,4),par.settings = standard.theme(color = FALSE),
	at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,names.attr=nome.mese[1:12],colorkey=list(space="right",width=0.5,height=1,labels=list(at=my.prec.levels.in.leyend)))

my.main<-"WTs Predicted Climatology with constant term";
my.cuts<-c(seq(0,50,1),seq(52.5,150,2.5),seq(155,200,5),seq(210,290,20),400);#my.labels<-c("0-30%","41-50","41-50","51-70%","61-70%","71-80%","81-90%","91-100%")
my.prec.levels.in.leyend<-c(0,25,50,75,100,150,200,250,300,350,400)
jet.colors.clim <-colorRampPalette(c("violet","blue", "#007FFF", "cyan","#7FFF7F", "yellow", "#FF7F00", "red", "#7F0000"))
my.palette<-jet.colors.clim
my.colors<-rev(my.palette(1000))
spplot(Var.grid,nome.mese.short[1:12],layout=c(3,4),par.settings = standard.theme(color = FALSE),
	at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,pch=19,cex=0.3,as.table=T,names.attr=nome.mese[1:12],colorkey=list(space="right",width=0.5,height=1,labels=list(at=my.prec.levels.in.leyend)))

# visualizza una composizione per il WT interpolato con il suo contributo medio mensile alla prec "climatologia del WT"
my.names<-nome.mese
my.cuts<- c(seq(1,30,1),35,40,50,70,100) # fa il log o la radice per diminuire le differenze tra i valori piu' alti e quelli piu' bassi in modo che non ci sia un colore che domina la legenda; occhio che funziona solo se la variabile da rappresentare non e' negativa!!!
my.labels=c(1,10,20,50,100) # i numeri che vuoi vedere visualizzati nella legenda, anche se nella mappa si visualizzano in realta' le loro radici
my.cuts.in.leyend<-my.labels # fa il log o la radice
Var.grid.temp<-Var.grid
ss<-which(Var.grid@data>100,arr.ind=T);ss1<-ss[,1];ss2<-ss[,2] # imposta a 100 tutti i pixel sopra 100 per non visualizzare una legenda distorta
if(dim(ss)[1]>0){for(s in 1:dim(ss)[1])Var.grid.temp@data[ss1[s],ss2[s]]=100}

lx=0.25 # lunghezza orizzontale di un mapa piccolo
ly=0.25 # lunghezza verticale di un mapa piccolo
g1=0.74 # altezza prima fila
g3=0.53  # altezza seconda fila
g8=0.32 # altezza terza fila
g5=0.11 # altezza quarta fila

my.map<-list()
for(mese in 1:12){
	my.main<-list(label=nome.mese[mese],cex=1)
	my.map[[mese]]<-spplot(Var.grid.temp,nome.mese.short[mese],main=my.main,par.settings = standard.theme(color = FALSE),
		at=my.cuts,col.regions=rev(jet.colors12(10000)),sp.layout=my.layout,cex=.5,names.attr=my.names[mese],legendEntries=my.labels,colorkey=FALSE)
}

# sotto la mappa di agosto aggiunge la legenda:
mese=8;my.main<-list(label=nome.mese[mese],cex=1)
my.map[[mese]]<-spplot(Var.grid.temp,nome.mese.short[mese],main=my.main,par.settings = standard.theme(color = FALSE),
	at=my.cuts,col.regions=rev(jet.colors12(10000)),sp.layout=my.layout,cex=.5,names.attr=my.names[mese],colorkey=list(space="bottom",width=0.5,height=3,labels=list(at=my.cuts.in.leyend,labels=my.labels)))
	
jpeg(paste("C:/nicola/precipitaciones/weather_types/mapas/14) composiciones_MOPREDAS_WTs_climatology_over_1_mm_leyenda_bonita/",wt,".jpg",sep=""),width=590,height=616,quality=100) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
#textplot(paste(WTs.type[wt],"Mean Rainfall Amount") ,cex=1,halign="center",valign="center",mar=c(0,0,0,0))
textplot(paste(wt,"MOPREDAS Clim. > 1 mm") ,cex=1.5,halign="center",valign="center",mar=c(0,0,0,0))
print(my.map[[1]], position= c(0,g1,0+lx,g1+ly),more=T) # fai ?print.trellis per la spiegazione di come dividere lo schermo con gli spplot
print(my.map[[2]], position= c(0.25,g1,0.25+lx,g1+ly),more=T) # (xmin, ymin, xmax, ymax)
print(my.map[[3]], position= c(0.50,g1,0.50+lx,g1+ly),more=T) 
print(my.map[[4]], position= c(0.75,g1,0.75+lx,g1+ly),more=T) 
print(my.map[[5]], position= c(0.75,g3,0.75+lx,g3+ly),more=T)
print(my.map[[6]], position= c(0.75,g8,0.75+lx,g8+ly),more=T)
print(my.map[[7]], position= c(0.75,g5,0.75+lx,g5+ly),more=T) 
print(my.map[[8]], position= c(0.50,g5-0.038,0.50+lx,g5+ly),more=T)
print(my.map[[9]], position= c(0.25,g5,0.25+lx,g5+ly),more=T)
print(my.map[[10]], position= c(0,g5,0+lx,g5+ly),more=T) 
print(my.map[[11]], position= c(0,g8,0+lx,g8+ly),more=T)
print(my.map[[12]], position= c(0,g3,0+lx,g3+ly),more=T)
dev.off()

	
} # chiude l'if su interpol!="NO"

if(altro==TRUE){#################################### CONFRONTO FINALE RICOSTRUZIONI #########################################################################
# nota: dato che a quanto pare usare la matrice di correlazione o covarianza nella PCA e' lo stesso, sia che i dati siano prima standardizzati o meno,
# inserisco solo il modello con i dati standardizzati e la matrice di covarianza
# carica una sessione di R con i dati che ti servono:
dat1=paste(dir_root,"/RData/R_session_v85_10PCs_stand_covar_1994-2003_nojack.RData",sep="")
dat2=paste(dir_root,"/RData/R_session_v86_10WTs_1994-2003_nojack.RData",sep="")
#dat1=paste(dir_root,"/RData/R_session_v88_10PCs_1948-1957_nojack.RData",sep="")
#dat2=paste(dir_root,"/RData/R_session_v89_10WTs_1948-1957_nojack.RData",sep="")

envir1<-new.env()
load(file=dat1, env=envir1) # carica tutti gli oggetti della sessione dat1 in memoria nello spazio envir1
envir2<-new.env()
load(file=dat2, env=envir2)
#ls(env=envir1)
#envir1$CV.valid

#Grafici finali con il confronto:
pdf(paste(dir_root,"/mapas/Comparison_2.pdf",sep=""),width=10) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
y.min<-0.1
y.max<-0.9

for(graf in 1:4){
par(mfrow=graph.yx);par(oma=c(1,1,3,1));  par(mar=c(2,2,2,2)) # oma controlla il bordo esterno a tutti i grafici, mar i bordi interni tra grafici
for(mese in int.mesi){
ind<-ifelse(graf<=2,"CV","COR")

if(graf==1){curva1<-envir1$CV.valid.mean[cla,mese,];curva2<-envir2$CV.valid.mean[cla,mese,]}
if(graf==2){curva1<-envir1$CV.calib.mean[cla,mese,];curva2<-envir2$CV.calib.mean[cla,mese,]}
if(graf==3){curva1<-envir1$COR.valid.mean[cla,mese,];curva2<-envir2$COR.valid.mean[cla,mese,]}
if(graf==4){curva1<-envir1$COR.calib.mean[cla,mese,];curva2<-envir2$COR.calib.mean[cla,mese,]}

print(plot(rep(0,predmax[mese]),type="n",xlab="Num.of predictors used", ylab=ind,ylim=c(y.min,y.max),yaxp=c(y.min,y.max,(y.max-y.min)*10),xaxp=c(0,predmax[mese],predmax[mese]))) # stampa un grafico vuoto con gli assi e basta
print(lines(curva1,type="o",col=col.metodo[1],cex=.6))
print(lines(curva2,type="o",col=col.metodo[2],cex=.6))
title(nome.mese[mese],line=0.5,cex=1.1)

leg1<-paste(ind,"with PCs")
leg2<-paste(ind,"with WTs")

legend("bottomright",c(leg1,leg2),col=col.metodo,lwd=.8)
} # chiude il for sui mesi per il grafico finale

# titolo grafico finale:
per<-ifelse((graf==1 | graf==3),"validation","calibration")
mtext(paste("Mean ",ind," for ",n.staz," stations for ",per," period ",start.valid,"-",end.valid,sep=""),outer=T,cex=1.2)
} # chiude il for su graf

dev.off()

library(ReadImages)
img <- read.jpeg("C:/nicola/north.arrow.jpg")
plot( 1:1000, 1:1000, type="n")
plot(img,add=T)

###################### MAPPA rapporto tra i coefficienti  ############################################
dat=paste(dir_root,"/RData/R_session_v151_regr_1950-2003_with_old_MOPREDAS.RData",sep="")

envir<-new.env()
load(file=dat, env=envir) # carica tutti gli oggetti della sessione dat1 in memoria nello spazio envir1

diff.coeff.WT.abs.data<-coeff.WT.abs.data
for(wt in 1:nWT[cla.rif]){
	# mappe del rapporto tra i coefficienti assoluti della regressione per ogni WT (= Absolute Intensity of each WT, ovvero il contributo assoluto in mm alla prec.totale dovuto a 1 giorno appartenente al WT considerato)
	my.main<-paste("(1+Prec.Intensity 1915-1949) / (1+Prec.Intensity 1950-2003) for ",WTs.names[[1]][wt],"Weather Type")
	my.cuts<-c(-1,-0.2,-0.05,-0.01,0.01,0.05,0.2,1); #my.labels<-c("0 mm","<1 mm","1-10 mm","11-20 mm")
	my.cuts<-c(-100,-20,-5,-1,1,5,20,100); #my.labels<-c("0 mm","<1 mm","1-10 mm","11-20 mm")
	my.cuts<-c(0,0.1,0.5,0.8,1.25,2,10,1000); #my.labels<-c("0 mm","<1 mm","1-10 mm","11-20 mm")
	my.colors<-rev(jet.colors5(1000)) #c("#00FFFF","#0099F8","blue","purple","magenta4","black")
	for(m in 1:12)diff.coeff.WT.abs.data[[wt]][[4+m]]<-((coeff.WT.abs.data[[wt]][[4+m]]+1)/(envir$coeff.WT.abs.data[[wt]][[4+m]]+1)) #/(media.prec.obs[,int.mesi[m]]) #/lastday(m,1999))
	if(interpol=="NO"){
		my.map<-spplot(diff.coeff.WT.abs.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		cuts=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T)
	} else {
		my.map<-spplot(diff.coeff.WT.abs.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,legendEntries=my.labels)
	}
	plot(my.map)
	
	colorkey=list(space="bottom",width=0.5,height=.8,labels=list(at=my.cuts.in.leyend,labels=my.labels,cex=.6)))		
	
	# mappe coefficienti assoluti regressione per ogni WT per il periodo 1950-2003 (= Absolute Intensity of each WT, ovvero il contributo assoluto in mm alla prec.totale dovuto a 1 giorno appartenente al WT considerato)
	# (la distribuzione spaziale e' uguale alle mappe dei contributi assoluti, ma non si moltiplica per la frequenza mensile dei WT)
	windows()
	my.main<-paste("Absolute contribute of 1 day of predictor",WTs.names[[1]][wt],"during 1950-2003")
	my.cuts<-c(0,0.01,1,10,1000); #my.labels<-c("0 mm","<1 mm","1-10 mm","11-20 mm")
	my.colors<-rev(jet.colors5(1000)) #c("#00FFFF","#0099F8","blue","purple","magenta4","black")
	if(interpol=="NO"){
		my.map<-spplot(envir$coeff.WT.abs.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		cuts=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T)
	} else {
		my.map<-spplot(envir$coeff.WT.abs.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,legendEntries=my.labels)
	}
	plot(my.map)
	

	# mappe coefficienti assoluti regressione per ogni WT per il periodo 1915-1949 (= Absolute Intensity of each WT, ovvero il contributo assoluto in mm alla prec.totale dovuto a 1 giorno appartenente al WT considerato)
	# (la distribuzione spaziale e' uguale alle mappe dei contributi assoluti, ma non si moltiplica per la frequenza mensile dei WT)
	windows()
	my.main<-paste("Absolute contribute of 1 day of predictor",WTs.names[[1]][wt],"during 1915-1949")
	my.cuts<-c(0,0.01,1,10,1000); #my.labels<-c("0 mm","<1 mm","1-10 mm","11-20 mm")
	my.colors<-rev(jet.colors5(1000)) #c("#00FFFF","#0099F8","blue","purple","magenta4","black")
	if(interpol=="NO"){
		my.map<-spplot(coeff.WT.abs.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		cuts=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T)
	} else {
		my.map<-spplot(coeff.WT.abs.data[[wt]],nome.mese.short[c(int.mesi)],layout=c(3,4),par.settings = standard.theme(color = FALSE),key.space = "right",
		at=my.cuts,col.regions=my.colors,main=my.main,sp.layout=my.layout,cex=0.5,as.table=T,legendEntries=my.labels)
	}
	plot(my.map)

}

















































################## calcolo promedio mappe  con indice teleconnessioni associato in fase positiva o negativa ###########################3

year.start=1850 #1946 # deve cominciare assieme o dopo il primo anno di pressioni giornaliere disponibili
year.end=2003
n.lat=10 # numero di file per ogni mappa raster (valori differenti di latitudine)
n.lon=25 # numero di colonne per ogni mappa raster (valori differenti di longitudine)
deg=5 # risoluzione del grid in gradi
angolo.basso.sinistra=c(-70, 25) # coordinate angolo in basso a sinistra di ogni raster di pressione input

st.dev=TRUE # se false, calcola il promedio di <n.min.max> mesi invece
st.dev.pos=1 # soglia per la individuzione dei mesi con desv.standard maggiore della soglia nel caso della fase positiva
st.dev.neg=-1 # soglia per la fase negativa
n.max.min= 6 # numero di mesi con indice massimo/minimo sui cui calcolare le medie giorno per giorno dei campi di pressione (indice alternativo a st.dev.pos e neg)


#datos.tel<-read.table("C:/nicola/pressure/teleconnessiones/2) INDICES_TELECO_2009_correlaciones.txt",header=TRUE,stringsAsFactors=FALSE,na.strings="-999")
datos.tel<-read.table("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/12) NAO_MOI_WeMOI_para_R_metodo_Michele.txt",header=TRUE,stringsAsFactors=FALSE,na.strings="-999")
#datos.SLP<-read.table("C:/nicola/pressure/database_emulate/3) database_in_txt.txt",header=FALSE,stringsAsFactors=FALSE,na.strings="-999") # database pressione giornaliera nel formato anno/mese/giorno/valori di pressione dei pixel in colonne
datos.SLP<-read.table("C:/nicola/pressure/database_emulate/2) emulate_normalizado_1850-2003.txt",header=FALSE,stringsAsFactors=FALSE,na.strings="-999") # database pressione giornaliera nel formato anno/mese/giorno/valori di pressione dei pixel in colonne

nomi.indici<-unique(datos.tel[[1]]) # elenco tutti indici teleconnessione di input (AO, NAO, ecc)
n.indici<-length(nomi.indici) # numero di indici differenti (AO, NAO, ...)
n.years<-year.end-year.start+1

nome.mese<-c("January","February","March","April","May","June","July","August","September","October","November","December")
nome.mese.short<-c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec")
jet.colors <-colorRampPalette(c("violet","blue", "#007FFF", "cyan","#7FFF7F", "yellow", "#FF7F00", "red", "#7F0000"))

# calcola le mappe associate a tutti i mesi con st.dev sopra o sotto un umbral fissato:
promedio4<-c()
for(i in nomi.indici){
	promedio3<-c()
	for(m in 1:12){ # mese
		tele<-subset(datos.tel,datos.tel[[1]]==i & datos.tel[[2]]>=year.start & datos.tel[[2]]<=year.end,select=c(1,2,2+m))
		promedio2<-c()
		for(x in 1:2){ # fai prima il promedio dei valori minimi dell'indice, poi dei valori max:
			mod<-ifelse(x==1,FALSE,TRUE)
			suffix<-ifelse(x==1,"Neg","Pos")
			tele2<-tele[order(tele[[3]],decreasing=mod),]
			daily.pression<-c()

			# cicla su ognuno dei mesi sui cui si calcola il promedio:
			n.mesi<-ifelse(suffix=="Neg",max(1,which(tele2[[3]]<st.dev.neg)),max(1,which(tele2[[3]]>st.dev.pos))) # (se suffix="Neg" i dati sono ordinati dal piu' negativo al piu' positivo); nel caso che non ci sia nessun mese che soddisfa la condizione, prende solo il primo
			if(st.dev==FALSE)n.mesi<-n.min.max
			
			for(y in 1:n.mesi){
				temp.pression<-subset(datos.SLP,datos.SLP[[1]]==tele2[[2]][y] & datos.SLP[[2]]==m)
				daily.pression<-rbind(daily.pression,temp.pression)
			}
			n.fila<-dim(daily.pression)[1]
			n.days<-n.fila/n.lat # ci sono 10 file per ogni raster, percio' se dividiamo per 10 il numero di file totali troviamo il numero di mappe raster ovvero il numero di giorni diversi su cui calcolare il promedio
			row.index<-seq(0,n.fila-n.lat,n.lat)
			
			promedio<-c()
			for(k in 1:n.lat){
				temp<-round(colMeans(daily.pression[row.index+k,]),1)
				promedio<-rbind(promedio,temp)
			}
			promedio<-cbind(i,m,suffix,promedio[,c(4:(n.lon+3))])
			promedio2<-rbind(promedio2,promedio)
		} # chiude il for su x
		promedio3<-rbind(promedio3,promedio2)
	}
	promedio4<-rbind(promedio4,promedio3)
}

# write.table(promedio4,"C:/nicola/pressure/promedio.txt",quote=FALSE,row.names=FALSE)
WorldPoly<- readShapePoly('C:/Projecto_Master/Limites Mundo/TM_WORLD_BORDERS-0.2.shp')
proj4string(WorldPoly) <- CRS("+proj=longlat")
my.polygon=list('sp.polygons',WorldPoly,first=F);my.layout=list(my.polygon) 

gt = GridTopology(cellcentre.offset = angolo.basso.sinistra, cellsize = c(deg,deg), cells.dim = c(n.lon, n.lat)) 
grd = SpatialGrid(gt)
proj4string(grd) <- CRS("+proj=longlat")
pressure.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,n.lon*n.lat)), proj4string = CRS("+proj=longlat +datum=WGS84"))

# carica i dati di tutte le medie possibili in pressure.grid:
for(i in nomi.indici){for(k in c("Neg","Pos")){for(mese in 1:12)pressure.grid@data[[paste(i,k,nome.mese[mese],sep="_")]]=as.numeric(t(promedio4[(1:n.lat)+(mese-1)*n.lat*2+ifelse(k=="Neg",0,n.lat)+(which(nomi.indici==i)-1)*n.lat*24,4:(3+n.lon)]))}}

# visualizza una mappa a scelta:
my.indice="NAO";my.fase="Pos"
spplot(pressure.grid,paste(my.indice,my.fase,nome.mese,sep="_"),as.table=T,col.regions=rev(jet.colors(1000)),sp.layout=my.layout,contour=TRUE,col='white',xlim=c(-70,50),ylim=c(25,70))

#salva tutte le mappe per ogni teleconnessione:
for(my.indice in nomi.indici){
	for(my.fase in c("Neg","Pos")){
		png(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/indice_",my.indice,"_",my.fase,".png",sep=""),width=1440,height=1200) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
		print(spplot(pressure.grid,paste(my.indice,my.fase,nome.mese,sep="_"),as.table=T,col.regions=rev(jet.colors(1000)),sp.layout=my.layout,contour=TRUE,col='white',xlim=c(-70,50),ylim=c(25,70)))
		dev.off()
	}
}

# calcola le mappe promedie associate a tutti i mesi senza nessun umbral: (= a climatologia su tutto il periodo)
promedio.all4<-c()
for(i in nomi.indici){
	promedio.all3<-c()
	for(m in 1:12){ # mese
		tele<-subset(datos.tel,datos.tel[[1]]==i & datos.tel[[2]]>=year.start & datos.tel[[2]]<=year.end,select=c(1,2,2+m))
		promedio.all2<-c()
		for(x in 1:2){ # in questo caso il promedio per suffix="Neg" e' lo stesso per suffix="Pos" perche' si considerano tutti i mesi
			mod<-ifelse(x==1,FALSE,TRUE)
			suffix<-ifelse(x==1,"Neg","Pos")
			tele2<-tele[order(tele[[3]],decreasing=mod),]
			daily.pression<-c()

			# cicla su tutti i mesi:			
			for(y in 1:n.years){
				temp.pression<-subset(datos.SLP,datos.SLP[[1]]==tele2[[2]][y] & datos.SLP[[2]]==m)
				daily.pression<-rbind(daily.pression,temp.pression)
			}
			n.fila<-dim(daily.pression)[1]
			n.days<-n.fila/n.lat # ci sono 10 file per ogni raster, percio' se dividiamo per 10 il numero di file totali troviamo il numero di mappe raster ovvero il numero di giorni diversi su cui calcolare il promedio
			row.index<-seq(0,n.fila-n.lat,n.lat)
			
			promedio.all<-c()
			for(k in 1:n.lat){
				temp<-round(colMeans(daily.pression[row.index+k,]),1)
				promedio.all<-rbind(promedio.all,temp)
			}
			promedio.all<-cbind(i,m,suffix,promedio.all[,c(4:(n.lon+3))])
			promedio.all2<-rbind(promedio.all2,promedio.all)
		} # chiude il for su x
		promedio.all3<-rbind(promedio.all3,promedio.all2)
	}
	promedio.all4<-rbind(promedio.all4,promedio.all3)
}

# carica i dati di tutte le medie possibili in pressure.all.grid:
pressure.all.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,n.lon*n.lat)), proj4string = CRS("+proj=longlat +datum=WGS84"))
for(i in nomi.indici){for(k in c("Neg","Pos")){for(mese in 1:12)pressure.all.grid@data[[paste(i,k,nome.mese[mese],sep="_")]]=as.numeric(t(promedio.all4[(1:n.lat)+(mese-1)*n.lat*2+ifelse(k=="Neg",0,n.lat)+(which(nomi.indici==i)-1)*n.lat*24,4:(3+n.lon)]))}}

# visualizza una mappa della pressione "climatologica" a scelta: (non dipende ne dall'indice ne dalla fase ma solo dal mese)
my.indice="NAO";my.fase="Pos"
spplot(pressure.all.grid,paste(my.indice,my.fase,nome.mese,sep="_"),as.table=T,names.attr=nome.mese,col.regions=rev(jet.colors(1000)),sp.layout=my.layout,contour=TRUE,col='white',xlim=c(-70,50),ylim=c(25,70))

# salva eventualmente le 12 mappe delle "climatologie" di pressione per ogni teleconnessione:
png(paste("C:/nicola/promedio_mensual_Emulate.png",sep=""),width=1440,height=1200) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
print(spplot(pressure.all.grid,paste(my.indice,my.fase,nome.mese,sep="_"),as.table=T,names.attr=nome.mese,col.regions=rev(jet.colors(1000)),sp.layout=my.layout,contour=TRUE,col='white',xlim=c(-70,50),ylim=c(25,70)))
dev.off()

# salva pure i 12 grid mensili della climatologia mensuale dei campi di pressione:
for(mese in 1:12)writeAsciiGrid(pressure.all.grid,paste("C:/nicola/promedio_EMULATE_",nome.mese[mese],".txt",sep=""),attr=paste("NAO_Neg_",nome.mese[mese],sep=""),na.value=-999)

# calcola la differenza tra le mappe con umbral e le mappe senza umbral (anomalia):
pressure.anom.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,n.lon*n.lat)), proj4string = CRS("+proj=longlat +datum=WGS84"))
for(i in nomi.indici){for(k in c("Neg","Pos")){for(mese in 1:12)pressure.anom.grid@data[[paste(i,k,nome.mese[mese],sep="_")]]=pressure.grid@data[[paste(i,k,nome.mese[mese],sep="_")]]-pressure.all.grid@data[[paste(i,k,nome.mese[mese],sep="_")]]}}

# visualizza una mappa delle ANOMALIE a scelta:
my.indice="WEMOI";my.fase="Pos"
spplot(pressure.anom.grid,paste(my.indice,my.fase,nome.mese,sep="_"),as.table=T,col.regions=rev(jet.colors(1000)),sp.layout=my.layout,contour=TRUE,col='white',xlim=c(-70,50),ylim=c(25,70))

# salva tutte le mappe delle ANOMALIE per ogni teleconnessione:
for(my.indice in nomi.indici){
	for(my.fase in c("Neg","Pos")){
		png(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/mapas anomalias/indice_",my.indice,"_",my.fase,".png",sep=""),width=1440,height=1200) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
		print(spplot(pressure.anom.grid,paste(my.indice,my.fase,nome.mese,sep="_"),as.table=T,col.regions=rev(jet.colors(1000)),sp.layout=my.layout,contour=TRUE,col='white',xlim=c(-70,50),ylim=c(25,70)))
		dev.off()
	}
}

#save.image("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/R_metodo_NO_Michele.RData")
save.image("C:/nicola/pressure/teleconnessiones/promedio_mensuale_ENSEMBLE_1850_2003.RData")

#########################################################################################################################################
# calcola le stesse mappe ma con il metodo alternativo di Michele: prima calcola le anomalie di pressione e poi la selezione dei 10 mesi:
year.start=1946 # deve cominciare assieme o dopo il primo anno di pressioni giornaliere disponibili
year.end=2003 # deve finire assieme o prima dell'ultimo anno di press.giorn.disponibili (nel caso dell'EMULATE il 2003!!!)
n.lat=10 # numero di file per ogni mappa raster (valori differenti di latitudine)
n.lon=25 # numero di colonne per ogni mappa raster (valori differenti di longitudine)
deg=5 # risoluzione del grid in gradi
angolo.basso.sinistra=c(-70, 25) # coordinate angolo in basso a sinistra di ogni raster di pressione input

n.max.min= 10 # numero di mesi con indice massimo/minimo sui cui calcolare le medie giorno per giorno dei campi di pressione (indice alternativo a st.dev.pos e neg)

#datos.tel<-read.table("C:/nicola/pressure/teleconnessiones/2) INDICES_TELECO_2009_correlaciones.txt",header=TRUE,stringsAsFactors=FALSE,na.strings="-999")
datos.tel<-read.table("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/12) NAO_MOI_WeMOI_para_R_metodo_Michele.txt",header=TRUE,stringsAsFactors=FALSE,na.strings="-999")
datos.SLP<-read.table("C:/nicola/pressure/database_emulate/2) emulate_normalizado_1850-2003.txt",header=FALSE,stringsAsFactors=FALSE,na.strings="-999") # database pressione giornaliera nel formato anno/mese/giorno/valori di pressione dei pixel in colonne

n.years<-year.end-year.start+1
nomi.indici<-unique(datos.tel[[1]]) # elenco tutti indici teleconnessione di input (AO, NAO, ecc)
n.indici<-length(nomi.indici) # numero di indici differenti (AO, NAO, ...)

#####

nome.mese<-c("January","February","March","April","May","June","July","August","September","October","November","December")
nome.mese.short<-c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec")
jet.colors <-colorRampPalette(c("violet","blue", "#007FFF", "cyan","#7FFF7F", "yellow", "#FF7F00", "red", "#7F0000"))
jet.colors3 <-colorRampPalette(c("blue","cyan","yellow", "#FF7F00", "red"))
jet.colors12<-colorRampPalette(c("mediumorchid4","purple","blue", "#007FFF", "cyan","#7FFF7F", "yellow", "white","#FF7F00", "red", "#7F0000","sienna","grey66","grey30","grey10"))
jet.colors13<-colorRampPalette(c("mediumorchid4","purple","blue", "#007FFF", "cyan", "white"))
jet.colors14<-colorRampPalette(c("mediumorchid4","purple","blue", "#007FFF", "cyan","#7FFF7F", "white","yellow","#FF7F00", "red", "#7F0000","sienna","grey66"))
jet.colors15<-colorRampPalette(c("mediumorchid4","purple","blue", "#007FFF", "cyan", "gold","white"))
jet.colors16<-colorRampPalette(c("mediumorchid4","purple","blue", "#007FFF", "cyan", "#7FFF7F","white"))
jet.colors17<-colorRampPalette(c("lightpink","mediumorchid4","purple","blue", "#007FFF", "cyan", "#7FFF7F","white"))
jet.colors18<-colorRampPalette(c("blue","cyan","#7FFF7F","pink","white","yellow","orange","red","darkred"))
jet.colors19<-colorRampPalette(c("gray6","saddlebrown","salmon","pink","white","yellow","orange","red","darkred"))
jet.colors20<-colorRampPalette(c("violetred","blue", "#007FFF", "cyan","#7FFF7F","white","yellow","orange","salmon","red","gray5"))
jet.colors21<-colorRampPalette(c("white","yellow","orange","salmon","red","violetred","blue","#007FFF","cyan","#7FFF7F"))


# toglie il 29 febbraio dai dati se no non riesco a calcolare le anomalie giornaliere:
datos.SLP.sin29<-subset(datos.SLP,datos.SLP[,2]!=2 | datos.SLP[,3]!=29)

first.year.SLP<-datos.SLP.sin29[1,1] 
diff.years<-year.start-first.year.SLP # calcola dopo quanto anni iniziano i calcoli rispetto al primo anno di dati di pressione

# calcolo per ogni giorno (tranne il 29 febb) e pixel il suo promedio su tutto il periodo, per poter calcolare poi l'anomalia:
datos.SLP.climatol<-array(NA,c(365,n.lat,n.lon),dimnames=c("day","lat","lon"))
for(day in 1:365){  
	for(i in 1:n.lat){
		for(j in 1:n.lon){
			datos.SLP.climatol[day,i,j]<-mean(datos.SLP.sin29[diff.years*365*n.lat+seq(0,(n.years-1)*365*n.lat,365*n.lat)+(day-1)*10+i,3+j],na.rm=T)
		}
	}
}

datos.SLP.climatol2<-c() # ripete 365 volte la climatologia diaria per cada pixel per adattarlo al formato di datos.SLP.sin29:
for(d in 1:365)datos.SLP.climatol2<-rbind(datos.SLP.climatol2,datos.SLP.climatol[d,,])

last.year.SLP<-datos.SLP.sin29[dim(datos.SLP.sin29)[1],1]
tot.years<-last.year.SLP-first.year.SLP+1
datos.SLP.climatol3<-matrix(datos.SLP.climatol2,365*n.lat*tot.years,n.lon,byrow=T)

# sottrae direttamente le due matrici tra di loro per calcolare l'anomalia:
datos.SLP.anom<-datos.SLP.sin29[,4:(3+n.lon)]-datos.SLP.climatol3

# aggiunge le prime tre colonne con anno mese giorno a sinistra:
datos.SLP.anom<-cbind(datos.SLP.sin29[,1:3],datos.SLP.anom)

promedio4.ano<-c()
for(i in nomi.indici){
	promedio3.ano<-c()
	for(m in 1:12){ # mese
		# estrae la lista dei valori mensili dell'indice considerato :
		tele<-subset(datos.tel,datos.tel[[1]]==i & datos.tel[[2]]>=year.start & datos.tel[[2]]<=year.end,select=c(1,2,2+m))
		promedio2.ano<-c()
		for(x in 1:2){ # fai prima il promedio dei valori minimi dell'indice, poi dei valori max:
			mod<-ifelse(x==1,FALSE,TRUE)
			suffix<-ifelse(x==1,"min","max")
			tele2<-tele[order(tele[[3]],decreasing=mod),] # come tele ma in ordine crescente o decrescente

			# cicla su ognuno degli n.max.min anni sui cui si calcola il promedio:
			daily.pression<-c()
			for(y in 1:n.max.min){
				temp.pression<-subset(datos.SLP.anom,datos.SLP.anom[[1]]==tele2[[2]][y] & datos.SLP.anom[[2]]==m)
				daily.pression<-rbind(daily.pression,temp.pression)
			}
			n.fila<-dim(daily.pression)[1]
			n.days<-n.fila/n.lat # ci sono <n.lat> file per ogni raster, percio' se dividiamo per <n.lat> il numero di file totali troviamo il numero di mappe raster ovvero il numero di giorni diversi su cui calcolare il promedio
			row.index<-seq(0,n.fila-n.lat,n.lat)
			
			promedio.ano<-c()
			for(k in 1:n.lat){
				temp<-round(colMeans(daily.pression[row.index+k,]),1)
				promedio.ano<-rbind(promedio.ano,temp)
			}
			promedio.ano<-cbind(i,m,suffix,promedio.ano[,c(4:(n.lon+3))])
			promedio2.ano<-rbind(promedio2.ano,promedio.ano)
		} # chiude il for su x
		promedio3.ano<-rbind(promedio3.ano,promedio2.ano)
	}
	promedio4.ano<-rbind(promedio4.ano,promedio3.ano)
}

WorldPoly<- readShapePoly('C:/Projecto_Master/Limites Mundo/TM_WORLD_BORDERS-0.2.shp')
proj4string(WorldPoly) <- CRS("+proj=longlat")
my.polygon=list('sp.polygons',WorldPoly,first=F);my.layout=list(my.polygon) 
my.layout=list(my.polygon) 

gt = GridTopology(cellcentre.offset = angolo.basso.sinistra, cellsize = c(deg,deg), cells.dim = c(n.lon, n.lat)) 
grd = SpatialGrid(gt)
proj4string(grd) <- CRS("+proj=longlat")
pressure.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,n.lon*n.lat)), proj4string = CRS("+proj=longlat +datum=WGS84"))

# carica i dati di tutte le medie possibili in pressure.mic.grid:
pressure.mic.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,n.lon*n.lat)), proj4string = CRS("+proj=longlat +datum=WGS84"))
for(i in nomi.indici){for(k in c("Neg","Pos")){for(mese in 1:12)pressure.mic.grid@data[[paste(i,k,nome.mese[mese],sep="_")]]=as.numeric(t(promedio4.ano[(1:n.lat)+(mese-1)*n.lat*2+ifelse(k=="Neg",0,n.lat)+(which(nomi.indici==i)-1)*n.lat*24,4:(3+n.lon)]))}}

# visualizza una mappa delle ANOMALIE di Michele a scelta (per verificare che fa tutto giusto):
my.indice="NAO";my.fase="Pos"
spplot(pressure.mic.grid,paste(my.indice,my.fase,nome.mese,sep="_"),as.table=T,col.regions=rev(jet.colors(1000)),sp.layout=my.layout,contour=TRUE,col='white',xlim=c(-70,50),ylim=c(25,70))

# salva tutte le mappe delle ANOMALIE di Michele per ogni teleconnessione:
for(my.indice in nomi.indici){
	for(my.fase in c("Neg","Pos")){
		png(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/mapas anomalias Michele/indice_",my.indice,"_",my.fase,".png",sep=""),width=1200,height=1000) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
		print(spplot(pressure.mic.grid,paste(my.indice,my.fase,nome.mese,sep="_"),as.table=T,col.regions=rev(jet.colors(1000)),sp.layout=my.layout,contour=TRUE,col='white',xlim=c(-70,50),ylim=c(25,70)))
		dev.off()
	}
}
































#################################################################################################################################################
# vecchio studio relazione tra WTs e teleconnessioni (solo per Iberian Peninsula):
nomi.WTs<-c("NE","E","SE","S","SW","W","NW","N","C","C.NE","C.E","C.SE","C.S","C.SW","C.W","C.NW","C.N","A","A.NE","A.E","A.SE","A.S","A.SW","A.W","A.NW","A.N")
WTs.conversion<-c(1,2,3,4,5,6,7,8,30,31.5,32.5,33.5,34.5,35.5,36.5,37.5,38.5,40,41.5,42.5,43.5,44.5,45.5,46.5,47.5,48.5)
segni<-c("Neg","Pos")

idWTs<-sort(unique(datos.WTs[[4]])) # elenco numeri corrispondenti ai WTs
nWTs<-length(idWTs)

linked.WTs<-array(NA,c(n.indici,2,12,nWTs),dimnames=list(nomi.indici,segni,nome.mese,nomi.WTs))
linked.years<-array(NA,c(n.indici,2,12,n.max.min),dimnames=list(nomi.indici,segni,nome.mese,c(1:n.max.min)))

for(i in nomi.indici){
	for(k in segni){
		for(mese in 1:12){
			tele<-subset(datos.tel,datos.tel[[1]]==i & datos.tel[[2]]>=year.start & datos.tel[[2]]<=year.end,select=c(1,2,2+mese))
			mod<-ifelse(k=="Neg",FALSE,TRUE)
			tele2<-tele[order(tele[[3]],decreasing=mod),]
			
			daily.WTs<-c()
			for(y in 1:n.max.min){
				temp.WTs<-subset(datos.WTs,datos.WTs[[1]]==tele2[[2]][y] & datos.WTs[[2]]==mese)
				daily.WTs<-rbind(daily.WTs,temp.WTs)
				linked.years[which(i==nomi.indici),which(k==segni),mese,y]<-tele2[[2]][y]
			}
			#n.fila<-dim(daily.WTs)[1]
			#n.days<-n.fila/n.lat
			
			fr.WTs<-table(daily.WTs[[4]]) # distr.di frequenza di ogni WTs (numero di giorni per tutto il periodo)
			#n.fr.WTs<-length(fr.WTs)
			#second.max<-sort(fr.WTs)[n.fr.WTs-1]
			#temp<-names(fr.WTs)[min(which(fr.WTs==second.max))] # seleziona il WT con la frequenza maggiore
			#linked.WTs[which(i==nomi.indici),which(k==segni),mese,]<-WTs.names[which(temp==WTs.conversion)]
			for(wt in WTs.conversion){
				if(length(which(names(fr.WTs)==wt))==0){fr.WTs<-c(fr.WTs,0);names(fr.WTs)[length(fr.WTs)]=wt}
			}
			x<-sort(as.numeric(names(fr.WTs)))
			y<-match(names(fr.WTs),x)
			z<-c()
			z[y]<-fr.WTs
			names(z)<-x
			linked.WTs[which(i==nomi.indici),which(k==segni),mese,]<-z
		}
	}
}

ftable(linked.WTs)

# cerca se ci sono 2 o + serie che hanno le stesse coordinate; in questi casi, le sposta di un metro piu' a nord in modo che si possa fare il kriging:
  lonlat<-paste(coordinates(infofile)[,1],coordinates(infofile)[,2]) # stringa con la long+lat di ogni stazione
  nlonlat<-length(lonlat)
  for(st in 1:nlonlat){
   ss<-which(lonlat==lonlat[st]) # vettore con tutte le righe della tabla che hanno la stessa lon e lat della riga staz (dovrebbe esserci 1 sola fila)
   nss<-length(ss)
   if(nss>1){
   #print(paste(st,listaz[st],ss[1],ss[2])) # riga per il debug; normalmente ci sono al massimo 2 stazioni nella stessa posizione
   for(k in 2:nss)infofile@coords[ss[k],2]=infofile@coords[ss[k],2]+k-1 # aumenta di k metri la latitudine (esclusa la prima stazione del gruppo)
   }  
  }

# crea un generico grid a <pixel.size> km in UTM30 che si sovrapponga a tutta la Penisola Iberica:
gt = GridTopology(cellcentre.offset = c(-70000, 3980000), cellsize = c(1000*pixel.size,1000*pixel.size), cells.dim = c(ceiling(1110/pixel.size), ceiling(890/pixel.size))) 
grd = SpatialGrid(gt)
n.pixels<-grd@grid@cells.dim[1]*grd@grid@cells.dim[2]
 proj4string(grd) <- CRS("+proj=utm +zone=30 +datum=WGS84") # +ellps=clrk66")
#summary(grd);plot(IpPoly);plot(grd,add=T) # visualizza il grid sovrapposto alla IP

#linked.years<-array(NA,c(n.indici,2,12,n.max.min),dimnames=list(nomi.indici,segni,nome.mese,c(1:n.max.min)))

# promedio<-array(NA,c(n.indici,2,n.staz,12))
# for(i in nomi.indici){for(k in segni){for(st in 1:n.staz){for(mese in 1:12){
	# promedio[which(i==nomi.indici),which(k==segni),st,mese]= (subset(dati,dati[[2]]==linked.years[which(i==nomi.indici),which(k==segni),mese,1])[st,2+mese]+subset(dati,dati[[2]]==linked.years[which(i==nomi.indici),which(k==segni),mese,2])[st,2+mese]+subset(dati,dati[[2]]==linked.years[which(i==nomi.indici),which(k==segni),mese,3])[st,2+mese]+subset(dati,dati[[2]]==linked.years[which(i==nomi.indici),which(k==segni),mese,4])[st,2+mese]+subset(dati,dati[[2]]==linked.years[which(i==nomi.indici),which(k==segni),mese,5])[st,2+mese])/5
# }}}}

promedio<-array(NA,c(n.indici,2,n.staz,12))
for(i in nomi.indici){for(k in segni){for(mese in 1:12){
	promedio[which(i==nomi.indici),which(k==segni),,mese]= (subset(dati,dati[[2]]==linked.years[which(i==nomi.indici),which(k==segni),mese,1])[,2+mese]+subset(dati,dati[[2]]==linked.years[which(i==nomi.indici),which(k==segni),mese,2])[,2+mese]+subset(dati,dati[[2]]==linked.years[which(i==nomi.indici),which(k==segni),mese,3])[,2+mese]+subset(dati,dati[[2]]==linked.years[which(i==nomi.indici),which(k==segni),mese,4])[,2+mese]+subset(dati,dati[[2]]==linked.years[which(i==nomi.indici),which(k==segni),mese,5])[,2+mese])/5
}}}

# interpola per ogni anno (ovvero crea un raster per ogni anno), a meno che non sia impostato interpolation="CLI", nel qual caso interpola il valore medio su tutto il periodo
int.dati<-c()

telecon<-infofile
# carica i dati dei valori mensili della freq. dei WTs in infofile in base all'anno considerato (o direttamente tutta la climatologia se interpol="CLI"):
 for(i in nomi.indici){for(k in segni){for(mese in 1:12){
	telecon[[4+(which(i==nomi.indici)-1)*24+(which(k==segni)-1)*12+mese]]<-promedio[which(i==nomi.indici),which(k==segni),,mese]
	names(telecon)[4+(which(i==nomi.indici)-1)*24+(which(k==segni)-1)*12+mese]=paste(i,k,nome.mese.short[mese],sep=".")
 }}}

# crea un grid vuoto (prec.grid) dove mettere i risultati dell'interpolazione e un'altro (void.grid) che rimanga sempre vuoto da usare come plantilla invece di infofile:
Prec.grid<-void.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,n.pixels)), proj4string = CRS("+proj=utm +zone=30 +datum=WGS84"))

# interpola ogni mese dell'anno (anche se la regressione non si fa su tutti i mesi),
# mette il risultato in Prec@grid ed arrotonda la precipitazione prevista alla prima cifra decimale per non occupare troppo spazio se poi la si salva su un .txt (tanto l'errore introdotto arrotondando e' trascurabile)::
#formul<-c(Jan~1,Feb~1,Mar~1,Apr~1,May~1,Jun~1,Jul~1,Aug~1,Sep~1,Oct~1,Nov~1,Dec~1)
for(i in nomi.indici){for(k in segni){for(mese in 1:12){ 
	v <- variogram(as.formula(paste(paste(i,k,nome.mese.short[mese],sep=".")," ~ 1",sep="")), telecon)
	#plot(v,type='b') # per vedere i punti del semivariogramma, type=b traccia anche una linea spezzata tra i punti, ma non e' il fit
	# calcola automaticamente tutti i parametri della curva di fit, basta dargli dei valori iniziali approssimativi!!!!!
	v.fit <- fit.variogram(v, model=vgm(psill=8000, model='Gau', range=200000, nugget=500))
	#v.fit #per vedere i parametri risultato del fit
	#plot(v,v.fit) # per vedere il semivariogramma + la curva di fit
	#b <- mean(DistData[[i]][[j+1]]) # solo per il simple kriging
	Prec.grid@data[[(which(i==nomi.indici)-1)*24+(which(k==segni)-1)*12+mese]]<-round(krige(formula=as.formula(paste(paste(i,k,nome.mese.short[mese],sep=".")," ~ 1",sep="")), locations=telecon, newdata=grd, model=v.fit,nmax=int.nmax)@data$var1.pred,1)
	# se desse problemi a fare il kriging prova a vedere se dipende da una cattiva curva del fit, prova magari a impostare un range del fit piu' corto.
	names(Prec.grid@data)[(which(i==nomi.indici)-1)*24+(which(k==segni)-1)*12+mese]=paste(i,k,nome.mese.short[mese],sep=".")
}}}

# seleziona i pixel di mare con overlay e li mette a NA in modo che non li disegni nella mappa finale:
sea.pixels<-which(is.na(overlay(grd,IpPoly))==T)
land.pixels<-(1:n.pixels)[-sea.pixels]
for(i in nomi.indici){for(k in segni){for(mese in 1:12)Prec.grid@data[[(which(i==nomi.indici)-1)*24+(which(k==segni)-1)*12+mese]][sea.pixels]=NA}}

my.points.name="Monthly Rainfall Distribution"
my.prec.levels<- c(seq(0,50,1),seq(52.5,150,2.5),seq(155,200,5),seq(210,290,20),1000)
my.prec.levels2<- c(0,1,5,10,20,30,50,70,100,150,200,300,500) # leyenda uguale a quella di Ricardo
my.prec.levels3<- c(-100,0,1000) # per vedere se ci sono pixel interpolati minori di 0
my.prec.levels4<-my.prec.levels*10

i="SCAN"
k="Neg"

#pdf(paste("C:/nicola/pressure/teleconnessiones","/",i,"_",k,".pdf",sep=""))
spplot(Prec.grid,zcol=paste(i,k,nome.mese.short,sep="."),at=my.prec.levels4,col.regions=rev(jet.colors(10000)),sp.layout=my.layout,as.table=T)
#dev.off()


































########################################################################################################################################
# Studio correlazioni tra prec.mensile e teleconnessioni: [codice 100% indipendente dal codice principale]
# (nota che gli anni su cui si interpola la prec e su cui si calcolano le correlazione e l'r2 sono quelli di input del database di prec,
#  percio' il database di teleconnessioni deve avere come minimo lo stesso periodo del database di prec)

dir_infofile="C:/nicola/precipitaciones/prec_mensuales_Iberia/infofile_Iberia_sin_-999_sin_Ceuta.xls" 
dir_datos="C:/nicola/precipitaciones/prec_mensuales_Iberia/datos_Iberia_sin_-999_sin_Ceuta.txt"
#dir_telec="C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/9) NAO_MOI_WeMOI_final.txt" # deve avere una cabecera, una prima colonna con gli anni e 12 colonne per ogni indice mensile nell'ordine: NAO MOI WEMOI
#dir_telec="C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/PCA/3) PAC_NAO_MOI_WEMOI_para_R.txt" # deve avere una cabecera, una prima colonna con gli anni e 12 colonne per ogni indice mensile nell'ordine: NAO MOI WEMOI (puo'anche iniziare e finire in anni diversi dai dati di prec)
dir_telec="C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/PCA/6) PAC_NAO_MOI_WEMOI_corregidas_para_R.txt" # deve avere una cabecera, una prima colonna con gli anni e 12 colonne per ogni indice mensile nell'ordine: NAO MOI WEMOI (puo'anche iniziare e finire in anni diversi dai dati di prec)

header_datos=TRUE # specifica se il file con i dati di prec (dir_datos) ha o meno una prima fila con l'intestazione (vale TRUE per il database MOPREDASP)
piu_1=TRUE # vale true se nel file di dati di prec <dir_datos> si e' aggiunto 1 a tutti i valori mensili di prec per evitare gli zeri
dec_mm=TRUE  # vale true se la prec.e'espressa in decimi di mm, false altrimenti
remove_2006=TRUE # vale true per togliere l'anno 2006 dal database (solo per il database MOPREDASP)
pixel.size=10      # lunghezza del lato di un pixel in km
int.nmax=15          # numero massimo di vicini usati nel Ordinary Kriging
y.start.corr=1946	# anno di inizio per il calcolo delle correlazioni tra indici teleconn e prec (deve iniziare dopo o insieme ai dati di prec e di corr.)
y.end.corr=2005		# anno finale per il calcolo delle correlazioni tra indici teleconn e prec (deve finire prima o insieme ai dati di prec e di corr.)

perlexe="C:/Toshiba/Strawberry/perl/bin/perl.exe"
pythonexe="C:/Python27/python.exe"
#####

nome.mese<-c("January","February","March","April","May","June","July","August","September","October","November","December")
nome.mese.short<-c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec")
jet.colors3 <-colorRampPalette(c("blue","cyan","yellow", "#FF7F00", "red"))
jet.colors12<-colorRampPalette(c("mediumorchid4","purple","blue", "#007FFF", "cyan","#7FFF7F", "yellow", "white","#FF7F00", "red", "#7F0000","sienna","grey66","grey30","grey10"))
jet.colors13<-colorRampPalette(c("mediumorchid4","purple","blue", "#007FFF", "cyan", "white"))
jet.colors14<-colorRampPalette(c("mediumorchid4","purple","blue", "#007FFF", "cyan","#7FFF7F", "white","yellow","#FF7F00", "red", "#7F0000","sienna","grey66"))
jet.colors15<-colorRampPalette(c("mediumorchid4","purple","blue", "#007FFF", "cyan", "gold","white"))
jet.colors16<-colorRampPalette(c("mediumorchid4","purple","blue", "#007FFF", "cyan", "#7FFF7F","white"))
jet.colors17<-colorRampPalette(c("lightpink","mediumorchid4","purple","blue", "#007FFF", "cyan", "#7FFF7F","white"))
jet.colors18<-colorRampPalette(c("blue","cyan","#7FFF7F","pink","white","yellow","orange","red","darkred"))
jet.colors19<-colorRampPalette(c("gray6","saddlebrown","salmon","pink","white","yellow","orange","red","darkred"))
jet.colors20<-colorRampPalette(c("violetred","blue", "#007FFF", "cyan","#7FFF7F","white","yellow","orange","salmon","red","gray5"))
jet.colors21<-colorRampPalette(c("white","yellow","orange","salmon","red","violetred","blue","#007FFF","cyan","#7FFF7F"))

infofile <- read.xls(dir_infofile,verbose=TRUE,fill=TRUE,header=T,skip=0,na.strings="-999",perl=perlexe,stringsAsFactors=FALSE)
names(infofile)<-c("CODIGO","NOMBRE","PROVINCIA","LATITUDE","LONGITUDE","ALTITUDE")

#borra le eventuali filas vacias:
infofile<-subset(infofile,infofile[[1]]!="")

#borra el eventuale primero espacio de los nombres de las estaciones que empiezan con un espacio " ":
ss<-which(substring(infofile[[2]],1,1)==" ")
for (i in ss)infofile[[2]][i]=substring(infofile[[2]][i],2,nchar(infofile[[2]][i]))

#borra el eventual primer character en los nombres de las estaciones que empiezan con un punto ".":
tt<-which(substring(infofile[[2]],1,1)==".")
for (i in tt)infofile[[2]][i]=substring(infofile[[2]][i],2,nchar(infofile[[2]][i]))

#ordina per nome stazione, provincia e anno:
#infofile2<-infofile[order(infofile[[2]],infofile[[3]],infofile[[4]]),]

# importa i dati di prec di tutte le stazioni elencate e converti i manca-dato -999 in NA:
# (stavolta non c'e' bisogno di fare un for per ogni stazione della lista perche' si suppone che tutti e solo i dati delle stazioni nella lista stiano nello stesso file di dati .txt):
dati<-read.table(dir_datos,header=header_datos,stringsAsFactors=FALSE,na.strings="-999")
names(dati)<-c("Codigo","Year","Jen","Feb","Mar","Apr","May","Jun","Jul","Ago","Sep","Oct","Nov","Dec")

# RITAGLI PREC #
 
 # toglie uno alla prec.di ogni mese perche' nel database si era aggiunto 1 a tutti i valori per evitare mesi con zero: (funziona anche se ci sono NA)
 if(piu_1==TRUE){for(m in 1:12)dati[[2+m]]<-dati[[2+m]]-1 }

# se ci sono valori uguali a -1 (erano dei vecchi zero che dovevano essere messi ad 1) li mette uguali a zero:
for(m in 1:12){ss<-which(dati[[2+m]]==-1);dati[[2+m]][ss]=0}

# toglie l'anno 2006 alle prec.di ogni serie perche' nel database MOPREDAS compare sempre senza dati:
if(remove_2006==TRUE)dati<-subset(dati,dati[[2]]!=2006)

# se i dati sono espressi in decimi di mm, divide la prec. per 10:
if(dec_mm==T)dati[,3:14]=dati[,3:14]/10

listaz<-unique(dati[[1]]);n.staz<-length(listaz)

# trasforma la colonna della prec.di dicembre nel dicembre climatologico perche' i dati di teleconnessione dal 1951 al 2000 sono disponibili
# solo con il dicembre climatologico e aggiunge un NA al primo anno:
#tt<-c(NA,dati[,14])
#dati[,14]<-tt[-length(tt)]

### trasforma le precipitazioni in anomalie mensili (su tutti gli anni disponibili) prima di interpolarle:
anom.start<-dati[1,2]
anom.end<-dati[dim(dati)[1],2]
n.years.anom<-anom.end-anom.start+1

# calcola il promedio di ogni mese su tutto il periodo:
#dati.prom<-array(NA,c(n.staz,12),dimnames=c("n.serie","month"))
#for(s in 1:n.staz)dati.prom[s,]<-colMeans(dati[(1+(s-1)*n.years.anom):(s*n.years.anom),3:14],na.rm=T)

# adatta la forma della matrice dei promedi alla matrice dei dati:
#dati.prom.full<-array(NA,c(n.staz*n.years.anom,12),dimnames=c("n.serie","month"))
#for(s in 1:n.staz)dati.prom.full[(1+(s-1)*n.years.anom):(s*n.years.anom),]<-matrix(dati.prom[s,],n.years.anom,12,byrow=T)

# divide direttamente le due matrici tra di loro per calcolare l'anomalia:
#dati.anom<-dati[,3:14]/dati.prom.full

# aggiunge le prime due colonne con anno mese a sinistra:
#dati.anom<-cbind(dati[,1:2],dati.anom)

### interpola le anomalie mensili:

# parametri grafici:
my.points.name="Monthly Rainfall Distribution"
my.prec.levels<- c(seq(0,50,1),seq(52.5,150,2.5),seq(155,200,5),seq(210,290,20),500)
my.prec.levels2<- c(0,1,5,10,20,30,50,70,100,150,200,300,500) # leyenda uguale a quella di Ricardo
my.prec.levels3<- c(-100,0,1000) # per vedere se ci sono pixel interpolati minori di 0

IpPoly<- readShapePoly('C:/Projecto_Master/Limites Espana/borde_peniberica_sin_islas_sin_proyeccion.shp')
# plot(IpPoly); summary(IpPoly); IpPoly$bbox
 
coordinates(infofile) <- c('LONGITUDE','LATITUDE')
#bbox(infofile)  #leggere i valori min e max delle coordinate
#plot(infofile,cex=0.3,col="light blue");plot(IpPoly,add=T) # solo per vedere dove sono le stazioni

 # proietta le stazioni in UTM30:
 proj4string(infofile) <- CRS("+proj=longlat") # +ellps=clrk66")
 infofile<-spTransform(infofile, CRS("+proj=utm +zone=30 +datum=WGS84"))
#summary(my.grid.values) #plot(infofile) # per vedere la forma della griglia proiettata!

# proietta il perimetro della penisola iberica a UTM30:
proj4string(IpPoly) <- CRS("+proj=longlat")
IpPoly<-spTransform(IpPoly, CRS("+proj=utm +zone=30 +datum=WGS84"))

my.points<-list('sp.points',infofile,pch=1,cex=0.2,col="black")
my.polygon<-list('sp.polygons',IpPoly,fill='transparent',first=F) # first=FALSE gli dice di NON disegnare il poligono per primo # altre opzioni di list: fill=0, lwd=3, lty=2
my.layout<-list(my.polygon) #,my.points)
my.polygon<-list('sp.polygons',IpPoly,fill='transparent',first=F) # first=FALSE gli dice di NON disegnare il poligono per primo # altre opzioni di list: fill=0, lwd=3, lty=2
my.layout<-list(my.polygon) 
my.layout2<-list(my.polygon,my.points) 

# cerca se ci sono 2 o + serie che hanno le stesse coordinate; in questi casi, le sposta di un metro piu' a nord in modo che si possa fare il kriging:
# temo che bisognerebbe attualizzarlo perche' basta che due stazioni siano nello stesso pixel per generare un warning: singular model quando si interpola
  lonlat<-paste(coordinates(infofile)[,1],coordinates(infofile)[,2]) # stringa con la long+lat di ogni stazione
  nlonlat<-length(lonlat)
  for(st in 1:nlonlat){
   ss<-which(lonlat==lonlat[st]) # vettore con tutte le righe della tabla che hanno la stessa lon e lat della riga staz (dovrebbe esserci 1 sola fila)
   nss<-length(ss) # se vale 1 vuol dire che va bene
   if(nss>1){
   #print(paste(st,listaz[st],ss[1],ss[2])) # riga per il debug; normalmente ci sono al massimo 2 stazioni nella stessa posizione
   for(k in 2:nss)infofile@coords[ss[k],2]=infofile@coords[ss[k],2]+k-1 # aumenta di k metri la latitudine (esclusa la prima stazione del gruppo)
   }  
  }

# crea un generico grid a <pixel.size> km in UTM30 che si sovrapponga a tutta la Penisola Iberica:
gt = GridTopology(cellcentre.offset = c(-70000, 3980000), cellsize = c(1000*pixel.size,1000*pixel.size), cells.dim = c(ceiling(1110/pixel.size), ceiling(890/pixel.size))) 
grd = SpatialGrid(gt)
n.pixels<-grd@grid@cells.dim[1]*grd@grid@cells.dim[2]
 proj4string(grd) <- CRS("+proj=utm +zone=30 +datum=WGS84") # +ellps=clrk66")
#summary(grd);plot(IpPoly);plot(grd,add=T) # visualizza il grid sovrapposto alla IP

# vecchie variabili grid bypassate dalle impostazioni generali: (ATTENZIONE: non ci devono essere mesi con -999 in nessun anno dentro il periodo impostato!!!)
yearB<-anom.start # anno iniziale interpolazione
yearE<-anom.end # anno finale interpolazione
all.rows=TRUE # vale true se i dati di prec importati hanno una fila per ogni anno di dati tra l'anno di inizio e l'anno di fine, false altrimenti

n.years<-yearE-yearB+1 
period<-yearB:yearE

# toglie gli anni di dati delle stazioni mensili di prec.fuori dal periodo considerato:
#dati.anom2<-subset(dati.anom,dati.anom[[2]]>=yearB & dati.anom[[2]]<=yearE)
dati2<-subset(dati,dati[[2]]>=yearB & dati[[2]]<=yearE)

# interpola per ogni anno (ovvero crea un raster per ogni anno)
#int.anom.dati<-c()
#infofile.anom<-infofile
int.dati<-c()
infofile2<-infofile

# carica i dati dei valori mensili di prec.in infofile2 in base all'anno considerato:
for(y in yearB:yearE){ 
	 for(mese in 1:12){
		 st<-1:n.staz
		 infofile2[[4+mese]]<-dati2[((st-1)*n.years+1)+y-yearB,2+mese]
		 names(infofile2)[4+mese]=nome.mese.short[mese]
	 }

	# crea un grid vuoto (prec.grid) dove mettere i risultati dell'interpolazione e un'altro (void.grid) che rimanga sempre vuoto da usare come plantilla invece di infofile:
	Prec.grid<-void.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,n.pixels)), proj4string = CRS("+proj=utm +zone=30 +datum=WGS84"))

	# interpola ogni mese dell'anno (anche se la regressione non si fa su tutti i mesi),
	# mette il risultato in Prec@grid ed arrotonda la precipitazione prevista alla prima cifra decimale per non occupare troppo spazio se poi la si salva su un .txt (tanto l'errore introdotto arrotondando e' trascurabile)::
	formul<-c(Jan~1,Feb~1,Mar~1,Apr~1,May~1,Jun~1,Jul~1,Aug~1,Sep~1,Oct~1,Nov~1,Dec~1)

	infofile2.sinNA<-infofile2
	for(mese in 1:12){ 
		# occhio che purtroppo le funzioni variogram e krige non accettano NA come dato, se ti dice "Error: dimensions do not match", c'e' qualche NA.
		# percio'per fare il variogramma gli NA vengono sostituiti con il valore medio mensile per la serie con NA, anche se non e' corretto, ma tanto servono solo per calcolare il variogramma
		ss<-which(is.na(infofile2[[4+mese]]))
		if(length(ss)>0){
			for(s in ss)infofile2.sinNA[[4+mese]][s]<-mean(dati2[((s-1)*n.years+1):(s*n.years),2+mese],na.rm=T)[[1]] 
		}
		v <- variogram(formul[[mese]], infofile2.sinNA)
		#plot(v,type='b') # per vedere i punti del semivariogramma, type=b traccia anche una linea spezzata tra i punti, ma non e' il fit
		# calcola automaticamente tutti i parametri della curva di fit, basta dargli dei valori iniziali approssimativi!!!!!
		v.fit <- fit.variogram(v, model=vgm(psill=8000, model='Gau', range=200000, nugget=500))
		#v.fit #per vedere i parametri risultato del fit
		#plot(v,v.fit) # per vedere il semivariogramma + la curva di fit
		#b <- mean(DistData[[i]][[j+1]]) # solo per il simple kriging
		#Prec.grid@data[[mese]]<-round(krige(formula=formul[[mese]], locations=infofile2.sinNA, newdata=grd, model=v.fit,nmax=int.nmax)@data$var1.pred,2)
		Prec.grid@data[[mese]]<-round(krige(formula=formul[[mese]], locations=infofile2.sinNA, newdata=grd, model=v.fit,nmax=int.nmax)@data$var1.pred,2)
		# se desse problemi a fare il kriging prova a vedere se dipende da una cattiva curva del fit, prova magari a impostare un range del fit piu' corto.
	};names(Prec.grid@data)<-nome.mese.short

	# seleziona i pixel di mare con overlay e li mette a NA in modo che non li disegni nella mappa finale:
	sea.pixels<-which(is.na(overlay(grd,IpPoly))==T)
	land.pixels<-(1:n.pixels)[-sea.pixels]
	for(mese in 1:12)Prec.grid@data[[mese]][sea.pixels]=NA

	# matrice della forma num.pixel/anno/gen/feb/.../dic che memorizza i dati di prec per tutti gli anni della interpolazione:
	int.dati<-rbind(int.dati,cbind(1:n.pixels,y,Prec.grid@data))
	my.grid.name=paste("Monthly Precipitation Grid for year ",y,sep="")
} # chiude il for su y

n.land.pixels<-length(land.pixels)

# riordina la matrice int.dati per la prima e seconda colonna (pixel e anno) in modo che sia nello stesso ordine della matrice dati:
int.dati<-int.dati[order(int.dati[,1],int.dati[,2]),]

# da qui in poi calcola le correlazioni con gli indici di teleconnessione:

# importa i dati degli indici di teleconnessione di gennaio: (occhio che non devono esserci -999!!!)
#dati.tele<-read.table("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/2) componentes_principales.txt",header=TRUE,stringsAsFactors=FALSE)
#dati.tele<-read.table("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/7) TELECO_1951-2000_Brunetti para R anno climatologico.txt",header=TRUE,stringsAsFactors=FALSE)
dati.tele<-read.table(dir_telec,header=TRUE,stringsAsFactors=FALSE)

# riduce gli anni in int.dati e in dati.tele affinche'comincino e terminino nel periodo impostato dall'utente per il calcolo delle correlazioni:
int.dati<-subset(int.dati,int.dati[[2]]>=y.start.corr & int.dati[[2]]<=y.end.corr)
dati.tele<-subset(dati.tele,dati.tele[[1]]>=y.start.corr & dati.tele[[1]]<=y.end.corr)

n.anni<-y.end.corr-y.start.corr+1

# aggiunge a destra la serie temporale di teleconnessioni, ripetendola uguale per ogni pixel:
tel.NAO<-tel.WEMOI<-tel.MOI<-array(NA,c(n.anni,12))
tel.NAO<-dati.tele[,2:13] # nel caso della PCA questo indice diventa la PC1 e gli altri due la PC2 e la PC3
tel.MOI<-dati.tele[,14:25]
tel.WEMOI<-dati.tele[26:37]

r.NAO<-r.WEMOI<-r.MOI<-p.NAO<-p.WEMOI<-p.MOI<-r2.NAO<-r2.WEMOI<-r2.MOI<-r2.NAO.WEMOI<-r2.NAO.MOI<-r2.MOI.WEMOI<-r2.NAO.MOI.WEMOI<-array(NA,c(12,n.pixels))
r2p.NAO<-r2p.MOI<-r2p.WEMOI<-r2p.rel.NAO<-r2p.rel.MOI<-r2p.rel.WEMOI<-r2.solape<-array(NA,c(12,n.pixels))

for(mese in 1:12){for(p in 1:n.pixels){
	temp<-int.dati[((p-1)*n.anni+1):(n.anni*p),2+mese] # serie temporale prec per il mese e il pixel scelto
	if(length(na.omit(temp))>0){
		r.NAO[mese,p]<-cor(temp,tel.NAO[,mese],method="pearson")
		r.MOI[mese,p]<-cor(temp,tel.MOI[,mese],method="pearson") 
		r.WEMOI[mese,p]<-cor(temp,tel.WEMOI[,mese],method="pearson")
		#p.NAO[mese,p]<-cor.test(temp,tel.NAO[,mese],method="pearson")$p.value
		#p.MOI[mese,p]<-cor.test(temp,tel.MOI[,mese],method="pearson")$p.value
		#p.WEMOI[mese,p]<-cor.test(temp,tel.WEMOI[,mese],method="pearson")$p.value
	} else {
		r.NAO[mese,p]<-r.MOI[mese,p]<-r.WEMOI[mese,p]<-p.NAO[mese,p]<-p.MOI[mese,p]<-p.WEMOI[mese,p]<-NA
}}}

r2.NAO<-r.NAO^2;r2.WEMOI<-r.WEMOI^2;r2.MOI<-r.MOI^2

 # R2 della regressione multipla con NAO e WEMOI vs la prec:
for(mese in 1:12){for(p in 1:n.pixels){
	prec.temp<-int.dati[((p-1)*n.anni+1):(n.anni*p),2+mese]
	if(length(na.omit(prec.temp))==n.anni){
		temp<-lm(prec.temp~.,data=as.data.frame(cbind(tel.NAO[,mese],tel.WEMOI[,mese])))
		r2.NAO.WEMOI[mese,p]<-summary(temp)$r.squared
}}}

for(mese in 1:12){for(p in 1:n.pixels){
	prec.temp<-int.dati[((p-1)*n.anni+1):(n.anni*p),2+mese]
	if(length(na.omit(prec.temp))==n.anni){
		temp<-lm(prec.temp~.,data=as.data.frame(cbind(tel.NAO[,mese],tel.MOI[,mese])))
		r2.NAO.MOI[mese,p]<-summary(temp)$r.squared
}}}

for(mese in 1:12){for(p in 1:n.pixels){
	prec.temp<-int.dati[((p-1)*n.anni+1):(n.anni*p),2+mese]
	if(length(na.omit(prec.temp))==n.anni){
		temp<-lm(prec.temp~.,data=as.data.frame(cbind(tel.WEMOI[,mese],tel.MOI[,mese])))
		r2.MOI.WEMOI[mese,p]<-summary(temp)$r.squared
}}}

for(mese in 1:12){for(p in 1:n.pixels){
	prec.temp<-int.dati[((p-1)*n.anni+1):(n.anni*p),2+mese]
	if(length(na.omit(prec.temp))==n.anni){
		temp<-lm(prec.temp~.,data=as.data.frame(cbind(tel.NAO[,mese],tel.MOI[,mese],tel.WEMOI[,mese])))
		r2.NAO.MOI.WEMOI[mese,p]<-summary(temp)$r.squared
}}}

# correlazioni tra NAO, MOI e WEMOI senza la precipitazione:
cor.NAO.MOI<-cor.NAO.WEMOI<-cor.MOI.WEMOI<-c()
for(mese in 1:12){
	cor.NAO.MOI[mese]<-cor(tel.NAO[,mese],tel.MOI[,mese])
	cor.MOI.WEMOI[mese]<-cor(tel.MOI[,mese],tel.WEMOI[,mese])
	cor.NAO.WEMOI[mese]<-cor(tel.NAO[,mese],tel.WEMOI[,mese])
}

# correlazioni parziali tra NAO, MOI e WEMOI: (uguali per tutta la penisola Iberica)
cor.p.NAO.MOI<-cor.p.NAO.WEMOI<-cor.p.MOI.WEMOI<-c()
cor.p.NAO.MOI<-(cor.NAO.MOI-(cor.NAO.WEMOI*cor.MOI.WEMOI))/sqrt((1-cor.NAO.WEMOI^2)*(1-cor.MOI.WEMOI^2))
cor.p.MOI.WEMOI<-(cor.MOI.WEMOI-(cor.NAO.MOI*cor.NAO.WEMOI))/sqrt((1-cor.NAO.MOI^2)*(1-cor.NAO.WEMOI^2))
cor.p.NAO.WEMOI<-(cor.NAO.WEMOI-(cor.NAO.MOI*cor.MOI.WEMOI))/sqrt((1-cor.NAO.MOI^2)*(1-cor.MOI.WEMOI^2))

cor.parcial.3.var<-function(x1,x2,x3){ # calcola la cor.parziale tra la var x1 e x2 al netto della x3
	cor.12<-cor(x1,x2)
	cor.13<-cor(x1,x3)
	cor.23<-cor(x2,x3)
	cor.12.3<-(cor.12-cor.13*cor.23)/sqrt((1-cor.13^2)*(1-cor.23^2))
	return(cor.12.3)
}

cor.parcial.4.var<-function(x1,x2,x3,x4){ # calcola la cor.parziale tra la var x1 e x2 al netto della x3 e x4
	cor.12.4<-cor.parcial.3.var(x1,x2,x4)
	cor.13.4<-cor.parcial.3.var(x1,x3,x4)
	cor.23.4<-cor.parcial.3.var(x2,x3,x4)
	cor.12.34<-(cor.12.4-cor.13.4*cor.23.4)/sqrt((1-cor.13.4^2)*(1-cor.23.4^2))
	return(cor.12.34)
}

# trasforma la prec in una variabile mensile come le altre ma che dipende anche dal pixel:
prec<-array(NA,c(n.anni,12,n.pixels))
for(mese in 1:12){for(p in 1:n.pixels){
	prec[,mese,p]<-int.dati[((p-1)*n.anni+1):(n.anni*p),2+mese] # serie temporale prec per il mese e il pixel scelto
}}

#prova<-cor.parcial.3.var(tel.NAO[,mese],tel.MOI[,mese],tel.WEMOI[,mese])
#prova2<-cor.parcial.3.var(tel.NAO[,mese],prec[,mese,p],tel.WEMOI[,mese])

cor.NAO.prec..MOI.WEMOI<-cor.MOI.prec..NAO.WEMOI<-cor.WEMOI.prec..NAO.MOI<-array(NA,c(12,n.pixels))

barraP<-winProgressBar("Analyzing data","Please wait...",0,12,0)
for(mese in 1:12){
	setWinProgressBar(barraP,mese,label=paste(nome.mese[mese]) )
	for(p in 1:n.pixels){
		cor.NAO.prec..MOI.WEMOI[mese,p]<-cor.parcial.4.var(tel.NAO[,mese],prec[,mese,p],tel.MOI[,mese],tel.WEMOI[,mese])
		cor.MOI.prec..NAO.WEMOI[mese,p]<-cor.parcial.4.var(tel.MOI[,mese],prec[,mese,p],tel.NAO[,mese],tel.WEMOI[,mese])
		cor.WEMOI.prec..NAO.MOI[mese,p]<-cor.parcial.4.var(tel.WEMOI[,mese],prec[,mese,p],tel.NAO[,mese],tel.MOI[,mese])
	}
}
close(barraP)

# calcola le 3 mappe di significativita' della correlazione di Pearson (in base al numero di anni di dati meno il num.di gradi di liberta', es: 61-2 nel nosto caso)
sig.10=0.2126 # correlazione minima in valore assoluto corrispondente al livello di significativita' dello 0.10 (two-tailed, 61 anni, due gradi di liberta)
sig.5=0.2521
sig.1=0.3274

sig.p.10=0.2162 # correlazione minima in valore assoluto corrispondente al livello di significativita' dello 0.10 (two-tailed, 61 anni, 4 gradi di liberta)

# colori di Jorge:
sig.NAO<-r.NAO;sig.MOI<-r.MOI;sig.WEMOI<-r.WEMOI
neg.1=-0.3 # rosso scuro corrisp. a corr.negativa e significativita' inferiore a 0.01 o 1% con il test a 2 code
neg.10=-0.2 # rosso chiaro corrisp. a corr.negativa e significativita' inferiore a 0.10 o 10%
pos.10=0.4 # azzurro corrisp. a corr.positiva e significativita'inferiore a 10%
pos.1=0.6 # blu corrispond. a corr.positiva s significativita'inferiore al 1%
no.sig=0.1 # giallo corrispon. a correl. non significativa al livello del 10%

sig.NAO[r.NAO <= -sig.10]<- neg.10
sig.NAO[r.NAO >= sig.10]<- pos.10
sig.NAO[r.NAO > -sig.10 & r.NAO < sig.10]<- no.sig
sig.NAO[r.NAO <= -sig.1]<- neg.1
sig.NAO[r.NAO >= sig.1]<- pos.1

sig.MOI[r.MOI <= -sig.10]<- neg.10
sig.MOI[r.MOI >= sig.10]<- pos.10
sig.MOI[r.MOI > -sig.10 & r.MOI < sig.10]<- no.sig
sig.MOI[r.MOI <= -sig.1]<- neg.1
sig.MOI[r.MOI >= sig.1]<- pos.1

sig.WEMOI[r.WEMOI <= -sig.10]<- neg.10
sig.WEMOI[r.WEMOI >= sig.10]<- pos.10
sig.WEMOI[r.WEMOI > -sig.10 & r.WEMOI < sig.10]<- no.sig
sig.WEMOI[r.WEMOI <= -sig.1]<- neg.1
sig.WEMOI[r.WEMOI >= sig.1]<- pos.1

r.sig.NAO<-r.NAO;r.sig.NAO[abs(r.NAO)<sig.10]<-0
r.sig.MOI<-r.MOI;r.sig.MOI[abs(r.MOI)<sig.10]<-0
r.sig.WEMOI<-r.WEMOI;r.sig.WEMOI[abs(r.WEMOI)<sig.10]<-0

r2.sig.NAO<-r2.NAO;r2.sig.NAO[abs(r2.NAO)<sig.10^2]<-0
r2.sig.MOI<-r2.MOI;r2.sig.MOI[abs(r2.MOI)<sig.10^2]<-0
r2.sig.WEMOI<-r2.WEMOI;r2.sig.WEMOI[abs(r2.WEMOI)<sig.10^2]<-0

r.p.sig.NAO<-cor.NAO.prec..MOI.WEMOI;r.p.sig.NAO[abs(cor.NAO.prec..MOI.WEMOI)<sig.p.10]<-0
r.p.sig.MOI<-cor.MOI.prec..NAO.WEMOI;r.p.sig.MOI[abs(cor.MOI.prec..NAO.WEMOI)<sig.p.10]<-0
r.p.sig.WEMOI<-cor.WEMOI.prec..NAO.MOI;r.p.sig.WEMOI[abs(cor.WEMOI.prec..NAO.MOI)<sig.p.10]<-0

# calcola la varianza per ognuna delle 7 aree dell'intersezione dei 3 cerchi delle varianze:
var1<-r2.NAO.MOI.WEMOI-r2.MOI.WEMOI  # r2 parziale NAO
var2<-r2.NAO.MOI.WEMOI-r2.NAO.MOI	# r2 parziale WEMOI
var3<-r2.NAO.MOI.WEMOI-r2.NAO.WEMOI	# r2 parziale MOI
var4<-r2.NAO.MOI.WEMOI-r2.MOI-var1-var2
var5<-r2.NAO.MOI.WEMOI-r2.WEMOI-var1-var3
var6<-r2.NAO.MOI.WEMOI-r2.NAO-var2-var3
var7<-r2.NAO.MOI.WEMOI-var1-var2-var3-var4-var5-var6
var4[var4<0]<-0
var5[var5<0]<-0
var6[var6<0]<-0
var7[var7<0]<-0
var.inters<-var4+var5+var6+var7
var.all<-r2.NAO.MOI.WEMOI
var.inters[var.inters<0]<-0
var.all[var.all<0]<-0
var8<-var1+var2
var9<-var1+var3
var10<-var2+var3
var8[abs(var8)<sig.10^2]<-0
var9[abs(var9)<sig.10^2]<-0
var10[abs(var10)<sig.10^2]<-0
var11<-var1;var11[abs(var11)<sig.10^2]<-0
var12<-var2;var12[abs(var12)<sig.10^2]<-0
var13<-var3;var13[abs(var13)<sig.10^2]<-0
var.parcial<-var1+var2+var3
var.parcial[abs(var.parcial)<sig.10^2]<-0

var.max.PC1.PC2.PC3<-var.max.NAO.MOI<-var.max.NAO.MOI.WEMOI<-var.max.escala.NAO.MOI<-array(NA,c(12,n.pixels))

# in realta' se stiamo studiando le PCs e' un confronto tra la PC1, la PC2 e la PC3:
var.max.PC1.PC2.PC3[abs(r.NAO)>abs(r.MOI) & abs(r.NAO)>abs(r.WEMOI)]<-1
var.max.PC1.PC2.PC3[abs(r.MOI)>abs(r.NAO) & abs(r.MOI)>abs(r.WEMOI)]<-2
var.max.PC1.PC2.PC3[abs(r.WEMOI)>abs(r.NAO) & abs(r.WEMOI)>abs(r.MOI)]<-3

# per il confronto tra NAO e MOi dobbiamo prima collegare ogni PCs al suo indice di origine:
NAO.to.PC=c(2,3,3,3,2,2,1,1,3,3,2,2)
MOI.to.PC=c(3,2,2,2,3,3,3,3,2,2,3,3)
WEMOI.to.PC=c(1,1,1,1,1,1,2,2,1,1,1,1)

for(mese in 1:12){
	if(NAO.to.PC[mese]==1)corr.NAO[mese,]<-r.NAO[mese,]
	if(NAO.to.PC[mese]==2)corr.NAO[mese,]<-r.MOI[mese,]
	if(NAO.to.PC[mese]==3)corr.NAO[mese,]<-r.WEMOI[mese,]
	if(MOI.to.PC[mese]==1)corr.MOI[mese,]<-r.NAO[mese,]
	if(MOI.to.PC[mese]==2)corr.MOI[mese,]<-r.MOI[mese,]
	if(MOI.to.PC[mese]==3)corr.MOI[mese,]<-r.WEMOI[mese,]
	if(WEMOI.to.PC[mese]==1)corr.WEMOI[mese,]<-r.NAO[mese,]
	if(WEMOI.to.PC[mese]==2)corr.WEMOI[mese,]<-r.MOI[mese,]
	if(WEMOI.to.PC[mese]==3)corr.WEMOI[mese,]<-r.WEMOI[mese,]
	var.max.NAO.MOI[mese,abs(corr.NAO[mese,])>=abs(corr.MOI[mese,])]<-1
	var.max.NAO.MOI[mese,abs(corr.NAO[mese,])<abs(corr.MOI[mese,])]<-2
	var.max.NAO.MOI.WEMOI[mese,abs(corr.NAO[mese,])>=abs(corr.MOI[mese,]) & abs(corr.NAO[mese,])>=abs(corr.WEMOI[mese,])]<-1
	var.max.NAO.MOI.WEMOI[mese,abs(corr.MOI[mese,])>=abs(corr.NAO[mese,]) & abs(corr.MOI[mese,])>=abs(corr.WEMOI[mese,])]<-2
	var.max.NAO.MOI.WEMOI[mese,abs(corr.WEMOI[mese,])>=abs(corr.NAO[mese,]) & abs(corr.WEMOI[mese,])>=abs(corr.MOI[mese,])]<-3
	ss<-which(abs(corr.NAO[mese,])>=abs(corr.MOI[mese,]))
	dd<-which(abs(corr.NAO[mese,])<abs(corr.MOI[mese,]))
	var.max.escala.NAO.MOI[mese,ss]<-abs(corr.NAO[mese,ss])
	var.max.escala.NAO.MOI[mese,dd]<-(-abs(corr.MOI[mese,dd]))
}

# crea un grid dove mettere i risultati:
r2.grid<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,n.pixels)), proj4string = CRS("+proj=utm +zone=30 +datum=WGS84"))

for(mese in 1:12){
	r2.grid@data[[paste("r.NAO.",mese,sep="")]]<-r.NAO[mese,]
	r2.grid@data[[paste("r.MOI.",mese,sep="")]]<-r.MOI[mese,]
	r2.grid@data[[paste("r.WEMOI.",mese,sep="")]]<-r.WEMOI[mese,]
	#r2.grid@data[[paste("p.NAO.",mese,sep="")]]<-p.NAO[mese,]
	#r2.grid@data[[paste("p.MOI.",mese,sep="")]]<-p.MOI[mese,]
	#r2.grid@data[[paste("p.WEMOI.",mese,sep="")]]<-p.WEMOI[mese,]
	r2.grid@data[[paste("r2.NAO.",mese,sep="")]]<-r2.NAO[mese,]
	r2.grid@data[[paste("r2.MOI.",mese,sep="")]]<-r2.MOI[mese,]
	r2.grid@data[[paste("r2.WEMOI.",mese,sep="")]]<-r2.WEMOI[mese,]
	r2.grid@data[[paste("sig.NAO.",mese,sep="")]]<-sig.NAO[mese,]
	r2.grid@data[[paste("sig.MOI.",mese,sep="")]]<-sig.MOI[mese,]
	r2.grid@data[[paste("sig.WEMOI.",mese,sep="")]]<-sig.WEMOI[mese,]
	r2.grid@data[[paste("var1.",mese,sep="")]]<-var1[mese,]
	r2.grid@data[[paste("var2.",mese,sep="")]]<-var2[mese,]
	r2.grid@data[[paste("var3.",mese,sep="")]]<-var3[mese,]
	r2.grid@data[[paste("var4.",mese,sep="")]]<-var4[mese,]
	r2.grid@data[[paste("var5.",mese,sep="")]]<-var5[mese,]
	r2.grid@data[[paste("var6.",mese,sep="")]]<-var6[mese,]
	r2.grid@data[[paste("var7.",mese,sep="")]]<-var7[mese,]
	r2.grid@data[[paste("var8.",mese,sep="")]]<-var8[mese,]
	r2.grid@data[[paste("var9.",mese,sep="")]]<-var9[mese,]
	r2.grid@data[[paste("var10.",mese,sep="")]]<-var10[mese,]
	r2.grid@data[[paste("var.inters.",mese,sep="")]]<-var.inters[mese,]
	r2.grid@data[[paste("var.all.",mese,sep="")]]<-var.all[mese,]
	r2.grid@data[[paste("var.parcial.",mese,sep="")]]<-var.parcial[mese,]
	r2.grid@data[[paste("var11.",mese,sep="")]]<-var11[mese,]
	r2.grid@data[[paste("var12.",mese,sep="")]]<-var12[mese,]
	r2.grid@data[[paste("var13.",mese,sep="")]]<-var13[mese,]
	r2.grid@data[[paste("cor1.formulon.",mese,sep="")]]<-cor.NAO.prec..MOI.WEMOI[mese,]
	r2.grid@data[[paste("cor2.formulon.",mese,sep="")]]<-cor.WEMOI.prec..NAO.MOI[mese,]
	r2.grid@data[[paste("cor3.formulon.",mese,sep="")]]<-cor.MOI.prec..NAO.WEMOI[mese,]
	r2.grid@data[[paste("cor12.formulon.",mese,sep="")]]<-cor.NAO.prec..MOI.WEMOI[mese,]+cor.WEMOI.prec..NAO.MOI[mese,]
	r2.grid@data[[paste("cor13.formulon.",mese,sep="")]]<-cor.NAO.prec..MOI.WEMOI[mese,]+cor.MOI.prec..NAO.WEMOI[mese,]
	r2.grid@data[[paste("cor23.formulon.",mese,sep="")]]<-cor.MOI.prec..NAO.WEMOI[mese,]+cor.WEMOI.prec..NAO.MOI[mese,]
	r2.grid@data[[paste("cor123.formulon.",mese,sep="")]]<-cor.NAO.prec..MOI.WEMOI[mese,]+cor.MOI.prec..NAO.WEMOI[mese,]+cor.WEMOI.prec..NAO.MOI[mese,]
	r2.grid@data[[paste("var1.formulon.",mese,sep="")]]<-cor.NAO.prec..MOI.WEMOI[mese,]^2
	r2.grid@data[[paste("var2.formulon.",mese,sep="")]]<-cor.WEMOI.prec..NAO.MOI[mese,]^2
	r2.grid@data[[paste("var3.formulon.",mese,sep="")]]<-cor.MOI.prec..NAO.WEMOI[mese,]^2
	r2.grid@data[[paste("var12.formulon.",mese,sep="")]]<-cor.NAO.prec..MOI.WEMOI[mese,]^2+cor.WEMOI.prec..NAO.MOI[mese,]^2
	r2.grid@data[[paste("var13.formulon.",mese,sep="")]]<-cor.NAO.prec..MOI.WEMOI[mese,]^2+cor.MOI.prec..NAO.WEMOI[mese,]^2
	r2.grid@data[[paste("var23.formulon.",mese,sep="")]]<-cor.MOI.prec..NAO.WEMOI[mese,]^2+cor.WEMOI.prec..NAO.MOI[mese,]^2
	r2.grid@data[[paste("var123.formulon.",mese,sep="")]]<-cor.NAO.prec..MOI.WEMOI[mese,]^2+cor.MOI.prec..NAO.WEMOI[mese,]^2+cor.WEMOI.prec..NAO.MOI[mese,]^2
	r2.grid@data[[paste("r.sig.NAO.",mese,sep="")]]<-r.sig.NAO[mese,]
	r2.grid@data[[paste("r.sig.MOI.",mese,sep="")]]<-r.sig.MOI[mese,]
	r2.grid@data[[paste("r.sig.WEMOI.",mese,sep="")]]<-r.sig.WEMOI[mese,]
	r2.grid@data[[paste("r.p.sig.NAO.",mese,sep="")]]<-r.p.sig.NAO[mese,]
	r2.grid@data[[paste("r.p.sig.MOI.",mese,sep="")]]<-r.p.sig.MOI[mese,]
	r2.grid@data[[paste("r.p.sig.WEMOI.",mese,sep="")]]<-r.p.sig.WEMOI[mese,]
	r2.grid@data[[paste("r2.sig.NAO.",mese,sep="")]]<-r2.sig.NAO[mese,]
	r2.grid@data[[paste("r2.sig.MOI.",mese,sep="")]]<-r2.sig.MOI[mese,]
	r2.grid@data[[paste("r2.sig.WEMOI.",mese,sep="")]]<-r2.sig.WEMOI[mese,]
	r2.grid@data[[paste("var.max.PC1.PC2.PC3.",mese,sep="")]]<-var.max.PC1.PC2.PC3[mese,]
	r2.grid@data[[paste("var.max.NAO.MOI.WEMOI.",mese,sep="")]]<-var.max.NAO.MOI.WEMOI[mese,]
	r2.grid@data[[paste("var.max.NAO.MOI.",mese,sep="")]]<-var.max.NAO.MOI[mese,]	
	r2.grid@data[[paste("var.max.escala.NAO.MOI.",mese,sep="")]]<-var.max.escala.NAO.MOI[mese,]	
}

my.cor.levels<-seq(-1,1,0.01)
my.cor.levels<-c(-1,-0.9,seq(-0.8,0.8,0.01),0.9,1) 
my.cor.levels2<-c(-1,seq(-0.9,0.9,0.01),1) 
my.cor.levels3<-seq(-1,1,0.01)
my.cor.levels4<-c(-0.8,-0.7,-0.6,seq(-0.5,0.5,0.01),0.6,0.7,0.8)
my.cor.levels4.sig.10<-c(seq(-0.8,-sig.10,0.01),seq(sig.10,0.8,0.01)) 
my.cor.levels.sig.10<-c(-1,seq(-0.9,-sig.10,0.01),0,seq(sig.10,0.9,0.01),1) 
my.cor.levels.sig.p.10<-c(-1,seq(-0.9,-sig.p.10,0.01),0,seq(sig.p.10,0.9,0.01),1) 
my.cor.levels.sig.10<-c(seq(-0.9,-sig.10,0.01),0,seq(sig.10,0.9,0.01)) 
my.cor.levels.sig.p.10<-c(seq(-0.9,-sig.p.10,0.01),0,seq(sig.p.10,0.9,0.01)) 

my.r2.levels<-c(seq(0,0.8,0.01),1)
my.r2.levels3<-c(seq(0,0.5,0.01),0.6,0.7,0.8,0.9,1)
my.r2.levels2<-c(-1,seq(-0.8,0.8,0.01),1)
my.r2.levels4<-seq(0,0.7,0.01)
my.r2.levels4.sig.10<-seq(sig.10^2,0.7,0.01)
lista.tel<-c("NAO","MOI","WEMOI","NAO.MOI","NAO.WEMOI","MOI.WEMOI","NAO.MOI.WEMOI")
lista.tel.short<-c("NAO","MOI","WEMOI")
jet.colors22<-colorRampPalette(c("midnightblue","skyblue","aquamarine","pink","red","darkred"))

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/PCA/max_correlation_NAO_MOI_escala_colores.pdf",sep=""),width=12,height=7) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.	
my.main="Max Correlation NAO (blue scale) y MOI (red scale)"
my.index<-paste("var.max.escala.NAO.MOI.",1:12,sep="")
my.names<-nome.mese
my.col.levels<-my.cor.levels4
my.col.regions<-rev(jet.colors22(1000))
print(spplot(r2.grid,zcol=my.index,layout=c(4,3),sp.layout=my.layout,at=my.col.levels,col.regions=my.col.regions,
	main=my.main,as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.1)))))	
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/PCA/max_correlation_NAO_MOI_WEMOI.pdf",sep=""),width=12,height=7) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
my.main="Max Correlation NAO (red), MOI (blue) y WEMOI (yellow)"
my.index<-paste("var.max.NAO.MOI.WEMOI.",1:12,sep="")
my.names<-nome.mese
print(spplot(r2.grid,zcol=my.index,layout=c(4,3),sp.layout=my.layout,at=c(0,1,2,3),col.regions=c("red","blue","gold"),
	main=my.main,as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(1,3,1)))))
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/PCA/max_correlation_PC1_PC2_PC3.pdf",sep=""),width=12,height=7) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
my.main="Max Correlation PC1 (red), PC2 (blue) y PC3 (yellow)"
my.index<-paste("var.max.PC1.PC2.PC3.",1:12,sep="")
my.names<-nome.mese
print(spplot(r2.grid,zcol=my.index,layout=c(4,3),sp.layout=my.layout,at=c(0,1,2,3),col.regions=c("red","blue","gold"),
	main=my.main,as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(1,3,1)))))
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/PCA/max_correlation_NAO_MOI.pdf",sep=""),width=12,height=7) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.	
my.main="Max Correlation NAO (red) y MOI (blue)"
my.index<-paste("var.max.NAO.MOI.",1:12,sep="")
my.names<-nome.mese
print(spplot(r2.grid,zcol=my.index,layout=c(4,3),sp.layout=my.layout,at=c(0,1,2),col.regions=c("red","blue"),
	main=my.main,as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(1,2,1)))))	
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/PCA/PAC_correlaciones_PC1_PC1_PC3_1946_2005_signific_10.pdf",sep=""),width=10,height=7)
for(mese in 1:12){
	my.col.regions=rev(jet.colors20(1000))
	my.col.levels=my.cor.levels4.sig.10
	my.main=nome.mese[mese]
	my.index<-c(paste("r.sig.",lista.tel.short,".",mese,sep=""))
	my.names<-c("r.sig.10.PC1","r.sig.10.PC2","r.sig.10.PC3")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				

	my.col.regions=jet.colors21(1000)
	my.col.levels=my.r2.levels4.sig.10
	my.main=nome.mese[mese]
	my.index<-c(paste("r2.sig.",lista.tel.short,".",mese,sep=""))
	my.names<-c("r2.sig.10.PC1","r2.sig.10.PC2","r2.sig.10.PC3")
	my.map2<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				
	
	print(my.map1,split= c(1,1,1,2),more=T)
	print(my.map2,split= c(1,2,1,2))
	print(ltext(350,260,label=my.main,cex=2)) 
}
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/PCA/PAC_correlaciones_PC1_PC2_PC3_1946_2005.pdf",sep=""),width=10,height=7)
for(mese in 1:12){
	my.col.regions=rev(jet.colors20(1000))
	my.col.levels=my.cor.levels4
	my.main=nome.mese[mese]
	my.index<-c(paste("r.",lista.tel.short,".",mese,sep=""))
	my.names<-c("r.PC1","r.PC2","r.PC3")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				

	my.col.regions=jet.colors21(1000)
	my.col.levels=my.r2.levels4
	my.main=nome.mese[mese]
	my.index<-c(paste("r2.",lista.tel.short,".",mese,sep=""))
	my.names<-c("r2.PC1","r2.PC2","r2.PC3")
	my.map2<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				

	print(my.map1,split= c(1,1,1,2),more=T)
	print(my.map2,split= c(1,2,1,2))
	print(ltext(350,260,label=my.main,cex=2)) 
}
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/correlaciones_parciales_NAO_MOI_WEMOI_Pearson_v13.pdf",sep=""),width=10,height=7)
my.col.regions=rev(jet.colors17(1000))

for(mese in 1:12){
	my.col.levels=my.r2.levels
	my.main=nome.mese[mese]
	my.index<-c(paste("var1.formulon.",mese,sep=""),paste("var3.formulon.",mese,sep=""),paste("var2.formulon.",mese,sep=""))
	my.names<-c("r2.p.NAO","r2.p.MOI","r2.p.WEMOI")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				

	my.col.levels=my.r2.levels
	my.main=nome.mese[mese]
	my.index<-c(paste("var12.formulon.",mese,sep=""),paste("var13.formulon.",mese,sep=""),paste("var23.formulon.",mese,sep=""))
	my.names<-c("r2.p.NAO+r2.p.WEMOI","r2.p.NAO+r2.p.MOI","r2.p.MOI+r2.p.WEMOI")
	my.map2<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				
		
	print(my.map1, split= c(1,1,1,2),more=T)
	print(my.map2, split= c(1,2,1,2))
	print(ltext(300,13,label=my.main,cex=1.5)) 	
}
dev.off()


pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/correlaciones_signif_NAO_MOI_WEMOI_Pearson_v12.pdf",sep=""),width=10,height=7)
my.col.regions=rev(jet.colors20(1000))

for(mese in 1:12){
	my.col.levels=my.cor.levels.sig.10
	my.main=nome.mese[mese]
	my.index<-c(paste("r.sig.",lista.tel.short,".",mese,sep=""))
	my.names<-c("r.sig.NAO","r.sig.MOI","r.sig.WEMOI")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				
		
	my.col.levels=my.cor.levels.sig.p.10
	my.main=nome.mese[mese]
	my.index<-c(paste("r.p.sig.",lista.tel.short,".",mese,sep=""))
	my.names<-c("r.p.sig.NAO","r.p.sig.MOI","r.p.sig.WEMOI")
	my.map2<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				
		
	print(my.map1, split= c(1,1,1,2),more=T)
	print(my.map2, split= c(1,2,1,2))
	print(ltext(300,13,label=my.main,cex=1.5)) 
				
}
dev.off()


pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/correlaciones_signif_NAO_MOI_WEMOI_Pearson_v11.pdf",sep=""),width=10,height=7) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
my.col.regions=rev(jet.colors20(1000))
my.col.levels=my.cor.levels.sig.10

for(mese in 1:12){
	my.main=nome.mese[mese]
	my.index<-c(paste("r.sig.",lista.tel.short,".",mese,sep=""),paste("r.p.sig.",lista.tel.short,".",mese,sep=""))
	my.names<-c("r.sig.NAO","r.sig.MOI","r.sig.WEMOI","r.p.sig.NAO","r.p.sig.MOI","r.p.sig.WEMOI")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,2),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,main=my.main,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				
	print(my.map1)
}
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/correlaciones_NAO_MOI_WEMOI_Pearson_v10.pdf",sep=""),width=10,height=7)
my.col.regions=rev(jet.colors20(1000))

for(mese in 1:12){
	my.col.levels=my.cor.levels.sig.p.10
	my.main=nome.mese[mese]
	my.index<-c(paste("cor1.formulon.",mese,sep=""),paste("cor3.formulon.",mese,sep=""),paste("cor2.formulon.",mese,sep=""))
	my.names<-c("r.p.NAO","r.p.MOI","r.p.WEMOI")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				

	my.col.levels=my.cor.levels.sig.10
	my.main=nome.mese[mese]
	my.index<-c(paste("cor12.formulon.",mese,sep=""),paste("cor13.formulon.",mese,sep=""),paste("cor23.formulon.",mese,sep=""))
	my.names<-c("r.p.NAO+r.p.WEMOI","r.p.NAO+r.p.MOI","r.p.MOI+r.p.WEMOI")
	my.map2<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				
		
	print(my.map1, split= c(1,1,1,2),more=T)
	print(my.map2, split= c(1,2,1,2))
	print(ltext(300,13,label=my.main,cex=1.5)) 	
}
dev.off()


pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/correlaciones_NAO_MOI_WEMOI_Pearson_v9.pdf",sep=""),width=10,height=7) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
my.col.regions=rev(jet.colors20(1000))
my.col.levels=my.cor.levels2

for(mese in 1:12){
	my.main=nome.mese[mese]
	my.index<-c(paste("r.",lista.tel.short,".",mese,sep=""),paste("cor1.formulon.",mese,sep=""),paste("cor3.formulon.",mese,sep=""),paste("cor2.formulon.",mese,sep=""))
	my.names<-c("r.NAO","r.MOI","r.WEMOI","r.p.NAO","r.p.MOI","r.p.WEMOI")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,2),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,main=my.main,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)				
	print(my.map1)
}
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/variancia_NAO_MOI_WEMOI_Pearson_v8.pdf",sep=""),width=7,height=10) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
my.col.regions=rev(jet.colors20(1000))
my.col.levels=my.cor.levels2

for(mese in 1:12){
	my.main=nome.mese[mese]
	my.index<-c(paste("r.",lista.tel.short,".",mese,sep=""))
	my.names<-c("r.NAO","r.MOI","r.WEMOI")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)

	my.index<-c(paste("cor1.formulon.",mese,sep=""),paste("cor3.formulon.",mese,sep=""),paste("cor2.formulon.",mese,sep=""))
	my.names<-c("r.p.NAO","r.p.MOI","r.p.WEMOI")
	my.map2<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))
		
	my.index<-c(paste("cor13.formulon.",mese,sep=""),paste("cor23.formulon.",mese,sep=""),paste("cor12.formulon.",mese,sep=""),paste("cor123.formulon.",mese,sep=""))
	my.names<-c("r.p.NAO+MOI","r.p.MOI+WEMOI","r.p.NAO+WEMOI","r.p.NAO+MOI+WEMOI")
	my.map3<-spplot(r2.grid,zcol=my.index,at=my.col.levels,col.regions=my.col.regions,layout=c(4,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))
		
	print(my.map1, split= c(1,1,1,3),more=T)
	print(my.map2, split= c(1,2,1,3),more=T)
	print(my.map3, split= c(1,3,1,3))
	print(ltext(300,13,label=my.main,cex=1.5)) # 300,10 se si toglie il print
}
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/variancia_NAO_MOI_WEMOI_Pearson_v7.pdf",sep=""),width=7,height=10) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
for(mese in 1:12){
	my.main=nome.mese[mese]
	my.index<-c(paste("r.",lista.tel.short,".",mese,sep=""))
	my.names<-c("r.NAO","r.MOI","r.WEMOI")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.r2.levels2,col.regions=jet.colors14(10000),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)
		
	my.index<-c(paste("var1.",mese,sep=""),paste("var3.",mese,sep=""),paste("var2.",mese,sep=""))
	my.names<-c("r2.p NAO","r2.p MOI","r2.p WEMOI")
	my.map2<-spplot(r2.grid,zcol=my.index,at=my.r2.levels3,col.regions=rev(jet.colors17(10000)),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	my.index<-c(paste("var1.formulon.",mese,sep=""),paste("var3.formulon.",mese,sep=""),paste("var2.formulon.",mese,sep=""))
	my.names<-c("r2.p.NAO form","r2.p.MOI form","r2.p.WEMOI form")
	my.map3<-spplot(r2.grid,zcol=my.index,at=my.r2.levels3,col.regions=rev(jet.colors17(10000)),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	my.index<-c(paste("cor1.formulon.",mese,sep=""),paste("cor3.formulon.",mese,sep=""),paste("cor2.formulon.",mese,sep=""))
	my.names<-c("r.p.NAO form","r.p.MOI form","r.p.WEMOI form")
	my.map4<-spplot(r2.grid,zcol=my.index,at=my.r2.levels2,col.regions=(jet.colors14(10000)),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	print(my.map1, split= c(1,1,1,4),more=T)
	print(my.map2, split= c(1,2,1,4),more=T)
	print(my.map3, split= c(1,3,1,4),more=T)
	print(my.map4, split= c(1,4,1,4))
	print(ltext(245,708,label=my.main,cex=1.5)) # 300,10 se si toglie il print
}
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/variancia_NAO_MOI_WEMOI_Pearson_v6.pdf",sep=""),width=7,height=10) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
for(mese in 1:12){
	my.main=nome.mese[mese]
	my.index<-c(paste("r.",lista.tel.short,".",mese,sep=""))
	my.names<-c("corr.NAO","corr.MOI","corr.WEMOI")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.r2.levels2,col.regions=jet.colors14(10000),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)
		
	my.index<-c(paste("var11.",mese,sep=""),paste("var13.",mese,sep=""),paste("var12.",mese,sep=""))
	my.names<-c("r2p NAO sig.","r2p MOI sig.10","r2p WEMOI sig.10")
	my.map2<-spplot(r2.grid,zcol=my.index,at=my.r2.levels3,col.regions=rev(jet.colors17(10000)),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	my.index<-c(paste("var8.",mese,sep=""),paste("var9.",mese,sep=""),paste("var10.",mese,sep=""))
	my.names<-c("r2p NAO + WEMOI","r2p NAO + MOI","r2p MOI + WEMOI")
	my.map3<-spplot(r2.grid,zcol=my.index,at=my.r2.levels3,col.regions=rev(jet.colors17(10000)),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	my.index<-c(paste("var.parcial.",mese,sep=""))	
	my.names<-c("r2 parciales(1+2+3)")
	my.map4<-spplot(r2.grid,zcol=my.index,at=my.r2.levels3,main="Sum NAOp+MOIp+WEMOIp",col.regions=rev(jet.colors17(10000)),layout=c(1,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	print(my.map1, split= c(1,1,1,4),more=T)
	print(my.map2, split= c(1,2,1,4),more=T)
	print(my.map3, split= c(1,3,1,4),more=T)
	print(my.map4, split= c(1,4,1,4))
	print(ltext(245,709,label=my.main,cex=1.5)) # 300,10 se si toglie il print
}
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/variancia_NAO_MOI_WEMOI_Pearson_v3.pdf",sep=""),width=7,height=10) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
for(mese in 1:12){
	my.main=nome.mese[mese]
	my.index<-c(paste("r.",lista.tel.short,".",mese,sep=""))
	my.names<-c("corr.NAO","corr.MOI","corr.WEMOI")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.r2.levels2,col.regions=jet.colors14(10000),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)
		
	my.index<-c(paste("var1.",mese,sep=""),paste("var3.",mese,sep=""),paste("var2.",mese,sep=""))
	my.names<-c("r2p NAO (1)","r2p MOI (3)","r2p WEMOI (2)")
	my.map2<-spplot(r2.grid,zcol=my.index,at=my.r2.levels3,col.regions=rev(jet.colors16(10000)),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	my.index<-c(paste("var8.",mese,sep=""),paste("var9.",mese,sep=""),paste("var10.",mese,sep=""))
	my.names<-c("r2p NAO + WEMOI","r2p NAO + MOI)","r2p MOI + WEMOI")
	my.map3<-spplot(r2.grid,zcol=my.index,at=my.r2.levels3,col.regions=rev(jet.colors16(10000)),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	my.index<-c(paste("var.parcial.",mese,sep=""),paste("var.all.",mese,sep=""))	
	my.names<-c("r2 parciales(1+2+3)","r2 all (1+...+7)")
	my.map4<-spplot(r2.grid,zcol=my.index,at=my.r2.levels3,col.regions=rev(jet.colors16(10000)),layout=c(2,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	print(my.map1, split= c(1,1,1,4),more=T)
	print(my.map2, split= c(1,2,1,4),more=T)
	print(my.map3, split= c(1,3,1,4),more=T)
	print(my.map4, split= c(1,4,1,4))
	print(ltext(245,709,label=my.main,cex=1.5)) # 300,10 se si toglie il print
}
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/variancia_NAO_MOI_WEMOI_Pearson_v2.pdf",sep=""),width=7,height=10) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
for(mese in 1:12){
	my.main=nome.mese[mese]
	my.index<-c(paste("r.",lista.tel.short,".",mese,sep=""))
	my.names<-c("corr.NAO","corr.MOI","corr.WEMOI")
	my.map1<-spplot(r2.grid,zcol=my.index,at=my.r2.levels2,col.regions=jet.colors14(10000),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,
		colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))) # ,contour=TRUE,col='gray',region=TRUE,labels=FALSE)
		
	my.index<-c(paste("var1.",mese,sep=""),paste("var3.",mese,sep=""),paste("var2.",mese,sep=""))
	my.names<-c("r2 NAO (1)","r2 MOI (3)","r2 WEMOI (2)")
	my.map2<-spplot(r2.grid,zcol=my.index,at=my.r2.levels3,col.regions=rev(jet.colors13(10000)),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	my.index<-c(paste("var4.",mese,sep=""),paste("var5.",mese,sep=""),paste("var6.",mese,sep=""))
	my.names<-c("r2 (4:NAO y WEMOI)","r2 (5:NAO y MOI)","r2 (6:MOI y WEMOI)")
	my.map3<-spplot(r2.grid,zcol=my.index,at=my.r2.levels3,col.regions=rev(jet.colors13(10000)),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	my.index<-c(paste("var7.",mese,sep=""),paste("var.parcial.",mese,sep=""),paste("var.all.",mese,sep=""))	
	my.names<-c("r2 (7:NAO y MOI y WEMOI)","r2 parciales(1+2+3)","r2 all (1+...+7)")
	my.map4<-spplot(r2.grid,zcol=my.index,at=my.r2.levels,col.regions=rev(jet.colors13(10000)),layout=c(3,1),sp.layout=my.layout,
		as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2))))

	print(my.map1, split= c(1,1,1,4),more=T)
	print(my.map2, split= c(1,2,1,4),more=T)
	print(my.map3, split= c(1,3,1,4),more=T)
	print(my.map4, split= c(1,4,1,4))
	print(ltext(245,709,label=my.main,cex=1.5)) # 300,10 se si toglie il print
}
dev.off()
	
pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/variancia_NAO_MOI_WEMOI_Pearson.pdf",sep=""),width=14,height=7) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
for(mese in 1:12){
	my.main=nome.mese[mese]
	#my.index<-c(paste("r.",lista.tel.short,".",mes,sep=""),paste("r2.",lista.tel.short,".",mes,sep=""),paste("r2p.rel.",lista.tel.short,".",mes,sep=""),paste("r2.NAO.MOI.WEMOI.",mes,sep=""),paste("r2.solape.",mes,sep=""))
	my.index<-c(paste("r.",lista.tel.short,".",mese,sep=""),paste("sig.",lista.tel.short,".",mese,sep=""),paste("r2.",lista.tel.short,".",mese,sep=""),
		paste("var1.",mese,sep=""),paste("var3.",mese,sep=""),paste("var2.",mese,sep=""),paste("var4.",mese,sep=""),paste("var5.",mese,sep=""),
		paste("var6.",mese,sep=""),paste("var7.",mese,sep=""),paste("var.inters.",mese,sep=""),paste("var.all.",mese,sep=""))	
	
	#my.names<-c(paste("corr.",lista.tel.short),paste("r2 ",lista.tel.short,sep=""),paste("Peso rel.",lista.tel.short,sep=""),"NAO+MOI+WEMOI","Solape")
	my.names<-c("corr.NAO","corr.MOI","corr.WEMOI","sign.NAO","sign.MOI","sign.WEMOI","r2 NAO","r2 MOI","r2 WEMOI","r2 NAO (1)","r2 MOI (3)","r2 WEMOI (2)","r2 (4:NAO y WEMOI)","r2 (5:NAO y MOI)","r2 (6:MOI y WEMOI)","r2 (7:NAO y MOI y WEMOI)","r2 inters.(4+5+6+7)","r2 all (1+...+7)")
	print(spplot(r2.grid,zcol=my.index,at=my.r2.levels2,col.regions=rev(jet.colors12(10000)),layout=c(6,3),sp.layout=my.layout,
		main=my.main,as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))))
}
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/correl_NAO_MOI_WEMOI_Pearson_sig10_0.2126.pdf",sep=""),width=14,height=7) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
for(mese in 1:12){
	my.main=nome.mese[mese]
	my.index<-c(paste("r.",lista.tel.short,".",mese,sep=""),paste("sig.",lista.tel.short,".",mese,sep=""))
	my.names<-c("corr.NAO","corr.MOI","corr.WEMOI","sign.NAO","sign.MOI","sign.WEMOI")
	print(spplot(r2.grid,zcol=my.index,at=my.r2.levels2,col.regions=rev(jet.colors12(10000)),layout=c(3,2),sp.layout=my.layout,
		main=my.main,as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))))
}
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/correlation_NAO_Pearson_12_meses.pdf",sep=""),width=12,height=7) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
my.main="Significacion Pearson correlation NAO vs prec."
my.index<-paste("r.NAO.",1:12,sep="")
my.names<-nome.mese
print(spplot(r2.grid,zcol=my.index,at=my.r2.levels2,col.regions=rev(jet.colors12(10000)),layout=c(4,3),sp.layout=my.layout,
	main=my.main,as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))))
dev.off()


pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/significacion_NAO_Pearson_12_meses_sig10_0.2126.pdf",sep=""),width=12,height=7) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
my.main="Significacion correlation NAO vs prec."
my.index<-paste("r.NAO.",1:12,sep="")
my.names<-nome.mese
print(spplot(r2.grid,zcol=my.index,at=my.r2.levels2,col.regions=rev(jet.colors12(10000)),layout=c(4,3),sp.layout=my.layout,
	main=my.main,as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))))
dev.off()

pdf(paste("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/p_value_NAO_Pearson.pdf",sep="")) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
my.main="p-value Pearson correlation NAO vs prec."
my.index<-paste("p.NAO.",1:12,sep="")
my.names<-nome.mese
print(spplot(r2.grid,zcol=my.index,at=my.r2.levels,col.regions=jet.colors13(10000),layout=c(4,3),sp.layout=my.layout,
	main=my.main,as.table=T,par.settings = standard.theme(color = FALSE),names.attr =my.names,colorkey=list(width=0.6,height=1,labels=list(at=seq(-1,1,0.2)))))
dev.off()

# tabla con numero di pixel significativi / numero di pixel totali:
area.sig.NAO<-array(NA,c(3,12),dimnames=list(c("10","5","1"),c(nome.mese.short)))
for(mese in 1:12){
	area.NAO.sig.10[mese]<-length(which(abs(var1[mese,])>sig.10^2))/n.land.pixels
	area.NAO.sig.5[mese]<-length(which(abs(var1[mese,])>sig.5^2))/n.land.pixels
	area.NAO.sig.1[mese]<-length(which(abs(var1[mese,])>sig.1^2))/n.land.pixels
	area.MOI.sig.10[mese]<-length(which(abs(var3[mese,])>sig.10^2))/n.land.pixels
	area.MOI.sig.5[mese]<-length(which(abs(var3[mese,])>sig.5^2))/n.land.pixels
	area.MOI.sig.1[mese]<-length(which(abs(var3[mese,])>sig.1^2))/n.land.pixels
	area.WEMOI.sig.10[mese]<-length(which(abs(var2[mese,])>sig.10^2))/n.land.pixels
	area.WEMOI.sig.5[mese]<-length(which(abs(var2[mese,])>sig.5^2))/n.land.pixels
	area.WEMOI.sig.1[mese]<-length(which(abs(var2[mese,])>sig.1^2))/n.land.pixels
}
	
save.image("C:/nicola/pressure/teleconnessiones/NAO_MOI_WEMOI/R_corr_prec_NAO_MOI_WEMOI_v20_Pearson.RData")


































################ CALCOLO + MAPPE VALORI MEDI PREC. ASSOCIATA AD OGNI WT USANDO IL DATABASE GIORNALIERO IP02 GIA'INTERPOLATO ################################
# (script indipendente)
y.start<-1950 # primo anno dati nel database di prec.interpolato
y.end<-2003 # ultimo anno dati
coord.system<-CRS("+proj=longlat +datum=WGS84") 
pixel.size<-0.20
xmin.box<--9.6
ymin.box<-36.0
num.x.pixels<-71 # in teoria si puo'evitare di specificarlo perche' dovrebbe essere pari a n.lon
num.y.pixels<-40 # in teoria si puo'evitare di specificarlo perche' dovrebbe essere pari a n.lat
resol.unit<-"DecDegr"

##################################################### COSTANTI E FUNZIONI #########################################################################
nome.mese<-c("January","February","March","April","May","June","July","August","September","October","November","December")
nome.mese.short<-c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec")
WTs.type<-c("NE","E","SE","S","SW","W","NW","N","C","C.NE","C.E","C.SE","C.S","C.SW","C.W","C.NW","C.N","A","A.NE","A.E","A.SE","A.S","A.SW","A.W","A.NW","A.N") 
WTs.type2<-c("NE","E","SE","S","SW","W","NW","N","C","CNE","CE","CSE","CS","CSW","CW","CNW","CN","A","ANE","AE","ASE","AS","ASW","AW","ANW","AN") 
WTs.color<-c(rep("black",8),rep("blue",9),rep("brown",9))
WTs.color2<-c(rep("black",26));WTs.color2[c(6,15,24)]="blue";WTs.color2[c(6,15,24)]="blue"
WTs.type.long<-c("Northeasterly (NE)","Easterly (E)","Southeasterly (SE)","Southerly (S)","Southwesterly (SW)","Westerly (W)","Northwesterly (NW)",
					"Northerly (N)","Cyclonic (C)","Cyc.Northeasterly (C.NE)","Cyc.Easterly (C.E)","Cyc.Southeasterly (C.SE)","Cyc.Southerly (C.S)",
					"Cyc.Southwesterly (C.SW)","Cyc.Westerly (C.W)","Cyc.Northwesterly (C.NW)","Cyc.Northerly (C.N)","Anticyclonic (A)",
					"Ant.Northeasterly (A.NE)","Ant.Easterly (A.E)","Ant.Southeasterly (A.SE)","Ant.Southerly (A.S)","Ant.Southwesterly (A.SW)",
					"Ant.Westerly (A.W)","Ant.Northwesterly (A.NW)","Ant.Northerly (A.N)")
WTs.type.very.long<-c("Northeasterly (NE)","Easterly (E)","Southeasterly (SE)","Southerly (S)","Southwesterly (SW)","Westerly (W)","Northwesterly (NW)",
					"Northerly (N)","Cyclonic (C)","Cyclonic Northeasterly (C.NE)","Cyclonic Easterly (C.E)","Cyclonic Southeasterly (C.SE)","Cyclonic Southerly (C.S)",
					"Cyclonic Southwesterly (C.SW)","Cyclonic Westerly (C.W)","Cyclonic Northwesterly (C.NW)","Cyclonic Northerly (C.N)","Anticyclonic (A)",
					"Anticyclonic Northeasterly (A.NE)","Anticyclonic Easterly (A.E)","Anticyclonic Southeasterly (A.SE)","Anticyclonic Southerly (A.S)","Anticyclonic Southwesterly (A.SW)",
					"Anticyclonic Westerly (A.W)","Anticyclonic Northwesterly (A.NW)","Anticyclonic Northerly (A.N)")
WTs.type.very.long2<-c("Northeasterly (NE)","Easterly (E)","Southeasterly (SE)","Southerly (S)","Southwesterly (SW)","Westerly (W)","Northwesterly (NW)",
					"Northerly (N)","Cyclonic (C)","Cyclonic Northeasterly (CNE)","Cyclonic Easterly (CE)","Cyclonic Southeasterly (CSE)","Cyclonic Southerly (CS)",
					"Cyclonic Southwesterly (CSW)","Cyclonic Westerly (CW)","Cyclonic Northwesterly (CNW)","Cyclonic Northerly (CN)","Anticyclonic (A)",
					"Anticyclonic Northeasterly (ANE)","Anticyclonic Easterly (AE)","Anticyclonic Southeasterly (ASE)","Anticyclonic Southerly (AS)","Anticyclonic Southwesterly (ASW)",
					"Anticyclonic Westerly (AW)","Anticyclonic Northwesterly (ANW)","Anticyclonic Northerly (AN)")
jet.colors <-colorRampPalette(c("violet","blue", "#007FFF", "cyan","#7FFF7F", "yellow", "#FF7F00", "red", "#7F0000"))
jet.colors2 <-colorRampPalette(c("violet","blue","cyan","#7FFF7F", "yellow", "#FF7F00", "red"))
jet.colors3 <-colorRampPalette(c("violet","blue","cyan","#7FFF7F", "yellow", "#FF7F00"))
jet.colors4 <-colorRampPalette(c("violet","blue","cyan","#7FFF7F", "yellow"))
jet.colors5 <-colorRampPalette(c("violet","blue","cyan","#7FFF7F"))
jet.colors6 <-colorRampPalette(c("violet","blue","cyan"))
jet.colors7 <-colorRampPalette(c("red4","violet","blue","cyan"))
jet.colors8 <-colorRampPalette(c("violet","blue","cyan", "yellow", "#FF7F00")) # senza il verde
jet.colors9 <-colorRampPalette(c("violet","blue","cyan", "yellow", "orange")) 
jet.colors10 <-colorRampPalette(c("red4","violet","blue","cyan","lightgreen"))
jet.colors11 <-colorRampPalette(c("red4","violet","blue","cyan", "yellow", "#FF7F00")) # come la 8 ma con in + il rosso scuro
jet.colors12 <-colorRampPalette(c("red4","violet","blue","cyan", "yellow"))
jet.colors13 <-colorRampPalette(c("violet","blue","cyan", "yellow", "darkgoldenrod3")) 
jet.colors14 <-colorRampPalette(c("red4","violet","blue","cyan","darkgoldenrod2")) 
jet.colors15 <-colorRampPalette(c("red4","violet","blue","cyan", "yellow", "darkgoldenrod3")) 
IpPoly.geograf='C:/Projecto_Master/Limites Espana/borde_peniberica_sin_islas_sin_proyeccion.shp'
IpIslesPoly.geograf='C:/Projecto_Master/Limites Espana/borde_peniberica_sin_africa_y_francia_sin_proyeccion.shp'

rescale.max<-function(my.array,val.max){ # funzione che prende un array e restituisce lo stesso array abbassando pero'tutti gli elementi piu'alti di val.max al valore val.max (utile per aggiustare le leggende dei grafici)
	ss<-which(my.array>val.max)
	my.array[ss]<-val.max 
	return(my.array)
}
rescale.min<-function(my.array,val.min){ # come rescale.max ma per i valori piu'piccoli di val.min che vengono cambiati a val.min
	ss<-which(my.array<val.min)
	my.array[ss]<-val.min
	return(my.array)
}
rescale<-function(my.array,val.min,val.max){ # unisce rescale.max con rescale.min
	ss<-which(my.array>val.max)
	my.array[ss]<-val.max 
	ss<-which(my.array<val.min)
	my.array[ss]<-val.min
	return(my.array)
}
####################################################### INPUT DATA ############################################################################
# importa la prec.giornaliera interpolata del Ip02:
pr.dd.int<-open.ncdf("C:/nicola/precipitaciones/weather_types/Ip02/Database_IBERIA_0.2/Iberia_0.2.nc") # carica il database Iberian02 in formato NetCDF
lon<-get.var.ncdf(pr.dd.int,"lon") # occhio che manca la fascia di pixel in corrispondenza al valore di lon=3.6!!! (perche' e' una colonna di NA) 
lat<-get.var.ncdf(pr.dd.int,"lat") # (ma tanto e' fuori dalla spagna, R li elimina sovrepponendo quelli per lon=3.8, tanto sono tutti pixel di mare tranne una isola delle baleari)
lon<-sort(c(lon,3.6)) # aggiunge alle coordinate il valore di lon=3.6 che non era incluso nel .NetCDF
n.lon<-length(lon);n.lat<-length(lat)
n.pixels<-n.lon*n.lat 
#day<-get.var.ncdf(pr.dd.int,"time") # per estrarre il giorno e l'ora di misura
n.days<-pr.dd.int$dim$time$len # numero di giorni totali del database
prec<-get.var.ncdf(pr.dd.int,"pr_T") # prec e' un array 70*40*19722 days che comincia il 1/1/1950 e finisce il 31/12/2003
prec<-round(prec,1)
prec<-aperm(prec,c(2,1,3)) # scambia la lat con la lon per poter visualizzare la matrice con la forma della penisola iberica con la lat in verticale e la lon in orizzontale
prec<-prec[n.lat:1,,] # inverte la latitudine per visualizzare la penisola iberica non capovolta
prec2<-array(NA,c(n.lat,n.lon,n.days))
prec2[,1:66,]<-prec[,1:66,];prec2[,68:71,]<-prec[,67:70,];prec2[,67,]<-NA
prec<-prec2 # aggiunge una colonna di NA al grid di prec, in corrispondenza di lon=3.6 (prima della quart'ultima colonna)
rm(prec2)
n.sea.pixels<-length(which(is.na(prec[,,1]))) # numero di pixel di mare
n.land.pixels<-n.pixels-n.sea.pixels

# importa i tipi di tempo:
WTs<-read.table("C:/nicola/precipitaciones/weather_types/26 WTs from begin year to end/WTs_from_EMULATE_nic.txt",stringsAsFactors=FALSE,header=FALSE)
names(WTs)=c("Year","Month","Day","WT")
idWT<-sort(unique(WTs[[4]])) # cosi' puoi trattare anche tipi di tempo numerici ma non interi
nWT=length(unique(WTs[[4]])) # numero di tipi di tempo della classificazione (es: 8, 9 o 10)

# restringi i tipi di tempo al periodo del grid di precipitazione: (1950-2003) E senza il 30 e 31 dicembre 2003 perche'mancano in Iberian02
WTs<-subset(WTs,WTs$Year>=y.start & WTs$Year<=y.end)
WTs<-WTs[-dim(WTs)[1],] # toglie il 31 dic dell'ultimo anno
WTs<-WTs[-dim(WTs)[1],] # toglie il 30 dic dell'ultimo anno
n.days<-dim(WTs)[1] # quindi alla fine i giorni sono 19721
y.tot<-y.end-y.start+1
nome.anni<-y.start:y.end
#year<-c();for(y in y.start:y.end)year<-c(year,rep(y,n.days.in.a.year(y))) #month<-c();for(y in y.start:y.end)month<-c(month,seq.months.in.a.year(y))

######################################################## ANALYSIS #############################################################################

# per ogni mese, calcola la somma dei grid di prec. per tutti gli anni del periodo senza dividere in base ai WTs:
prec.sum<-array(0,c(n.lat,n.lon,12),dimnames=list(rev(lat),lon,nome.mese)) # array con i grid somma della prec. mensile (lat/lon/mese)
righe<-list();for(mese in 1:12)righe[[mese]]<- which(WTs$Month==mese) # lista di 12 elenchi, uno per ogni mese, con le righe di WTs (ovvero i giorni) appartenenti a quel mese in tutto il periodo
for(mese in 1:12){for(d in righe[[mese]]){prec.sum[,,mese]<-prec.sum[,,mese]+prec[,,d]}}

# per ogni mese, calcola la somma dei grid di prec.per tutto il periodo e li divide per il numero di anni in modo da creare la climatologia su tutto il periodo:
prec.clim<-array(0,c(n.lat,n.lon,12)) # array con i grid somma della prec. mensile diviso per il numero di anni(lat/lon/mese)
prec.clim<-prec.sum/y.tot
	
# per ogni mese e per ogni WT, calcola la somma dei grid di prec su tutti gli anni del periodo:
prec.wt.sum<-array(0,c(n.lat,n.lon,nWT,12),dimnames=list(rev(lat),lon,WTs.type,nome.mese))
righe.wt<-list();for(mese in 1:12){for(wt in 1:nWT){righe.wt[[mese*100+wt]]<-which(WTs$Month==mese & WTs$WT==wt)}}
for(mese in 1:12){for(wt in 1:nWT){for(d in righe.wt[[mese*100+wt]]){prec.wt.sum[,,wt,mese]<-prec.wt.sum[,,wt,mese]+prec[,,d]}}}

# per ogni mese e per ogni WT, calcola la somma dei grid di prec per tutto il periodo normalizzata per il numero di mesi in modo da avere la climatologia di ogni WT:
prec.wt.clim<-array(0,c(n.lat,n.lon,nWT,12),dimnames=list(rev(lat),lon,WTs.type,nome.mese))  # lista di array con i grid somma della prec.mensile di ogni WT divisa per il numero di mesi
for(mese in 1:12){for(wt in 1:nWT)prec.wt.clim[,,wt,mese]<-round(prec.wt.sum[,,wt,mese]/y.tot,1)}

# per ogni mese e per ogni WT, calcola la somma dei grid di prec per tutto il periodo e la normalizza per la prec.totale per tutto il periodo: 
# (cioe'il contributo relativo o Percentage Contribution)(percentuale arrotondata al secondo decimale)
prec.wt.sum.norm<-array(0,c(n.lat,n.lon,nWT,12),dimnames=list(rev(lat),lon,WTs.type,nome.mese)) # lista di array con i grid somma della prec.mensile normalizzata di ogni WT
for(mese in 1:12){for(wt in 1:nWT){prec.wt.sum.norm[,,wt,mese]<-100*round(prec.wt.sum[,,wt,mese]/prec.sum[,,mese],4)}}

# conta il numero di giorni in cui appare un WT per tutto il periodo senza dividere per il numero di anni: (e' indipendente dal pixel)
wt.n.days<-array(NA,c(nWT,12),dimnames=list(WTs.type,nome.mese.short))
for(mese in 1:12){for(wt in 1:nWT){wt.n.days[wt,mese]<-length(righe.wt[[mese*100+wt]])}} 

# calcola la frequenza di ogni WT come numero medio di giorni per mese:
wt.n.days.mean<-wt.n.days/y.tot

# Precipitation Intensity (in mm/day) per ogni WT,mese e pixel (includendo pero' anche i giorni senza pioggia)
prec.wt.int<-array(NA,c(n.lat,n.lon,nWT,12),dimnames=list(rev(lat),lon,WTs.type,nome.mese))
for(mese in 1:12){for(wt in 1:nWT)prec.wt.int[,,wt,mese]<-prec.wt.sum[,,wt,mese]/wt.n.days[wt,mese]} # occhio ai NaN che si formano quando si divide per 0

# Precipitation Efficiency per ogni WT, mese e pixel (Prec.Efficiency= # dias de lluvia >=1mm del WT en todo el periodo / # # dias de lluvia del WT e todo el periodo
prec.wt.eff<-array(NA,c(n.lat,n.lon,nWT,12),dimnames=list(rev(lat),lon,WTs.type,nome.mese))
wt.n.rain.days<-array(0,c(n.lat,n.lon,nWT,12),dimnames=list(rev(lat),lon,WTs.type,nome.mese)) # conta il numero di giorni del WT con pioggia su tutto il periodo
temp<-prec;temp[which(prec>=1)]<-1;temp[which(prec<1)]<-0 # temp e' come prec ma e' fatta solo di 0 e di 1 dove la pioggia e' >1 mm (e di NA sul mare)
for(mese in 1:12){for(wt in 1:nWT){for(d in righe.wt[[mese*100+wt]]){wt.n.rain.days[,,wt,mese]<-wt.n.rain.days[,,wt,mese]+temp[,,d]}}}
for(mese in 1:12){for(wt in 1:nWT)prec.wt.eff[,,wt,mese]<-100*round(wt.n.rain.days[,,wt,mese]/wt.n.days[wt,mese],3)}

# (tabla) area, o sea % di pixel con prec.wt.clim > threshold (mm)
threshold=1
area.wt.clim.threshold<-array(NA,c(nWT,12),dimnames=list(WTs.type,nome.mese))
for(mese in 1:12)for(wt in 1:nWT)area.wt.clim.threshold[wt,mese]<-length(which(prec.wt.clim[,,wt,mese]>threshold))/n.land.pixels 
tab.area<-100*round(area.wt.clim.threshold,3) # arrotonda e trasforma i valori in percentuali
tab.area<-cbind(tab.area,round(rowMeans(tab.area),1))

# calcolo soglie percentili (eliminando i giorni con meno di 1 mm di pioggia):
percentile=c(0.05,0.10,0.20,0.25,0.50,0.75,0.80,0.90,0.95) # valori scelti come soglie
reverse=c(TRUE,TRUE,TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,FALSE) # vale TRUE per gli indici come gli R10p che devono contare i giorni AL DI SOTTO di quel percentile invece che al di sopra (fino al percentile 0.50 incluso si contano quelli al di sotto)
percentiles<-array(NA,c(n.lat,n.lon,12,length(percentile)),dimnames=list(rev(lat),lon,nome.mese,percentile))
for(mese in 1:12)for(i in 1:n.lat)for(j in 1:n.lon)if(!is.na(prec[i,j,1])){
	temp<-prec[i,j,righe[[mese]]]
	ss<-which(prec[i,j,righe[[mese]]]<1)
	percentiles[i,j,mese,]<-quantile(temp[-ss],percentile,type=4)
}
righe.by.year<-list() # posizione elementi della matrice prec[,,d] corrispondenti alle righe con giorni appartenenti al mese e anno voluti
for(mese in 1:12){
	righe.by.year[[mese]]<-list()
	for(year in 1:y.tot)righe.by.year[[mese]][[year]]<-which(WTs$Month==mese & WTs$Year==y.start+year-1)
}
n.days.above<-array(NA,c(n.lat,n.lon,12,y.tot,length(percentile)),dimnames=list(rev(lat),lon,nome.mese,nome.anni,percentile))
barraP<-winProgressBar("Analyzing Percentiles","Please wait...",0,length(percentile),0)
for(n.p in 1:length(percentile)){
	if(reverse[n.p]==FALSE){
		for(mese in 1:12)for(i in 1:n.lat)for(j in 1:n.lon)for(year in 1:y.tot)if(!is.na(prec[i,j,1])){
			temp<-prec[i,j,righe.by.year[[mese]][[year]]]
			n.days.above[i,j,mese,year,n.p]<-length(which(temp>percentiles[i,j,mese,n.p]))
		}
	} else {
		for(mese in 1:12)for(i in 1:n.lat)for(j in 1:n.lon)for(year in 1:y.tot)if(!is.na(prec[i,j,1])){
			temp<-prec[i,j,righe.by.year[[mese]][[year]]]
			n.days.above[i,j,mese,year,n.p]<-length(which(temp>=1 & temp<percentiles[i,j,mese,n.p]))
		}
	}
	setWinProgressBar(barraP,n.p)
};close(barraP)

n.days.above.medio<-array(NA,c(n.lat,n.lon,12,length(percentile)),dimnames=list(rev(lat),lon,nome.mese,percentile)) # media TEMPORALE su tutti gli anni
for(mese in 1:12)for(i in 1:n.lat)for(j in 1:n.lon)for(n.p in 1:length(percentile))if(!is.na(prec[i,j,1]))n.days.above.medio[i,j,mese,n.p]<-mean(n.days.above[i,j,mese,,n.p])

# analisi per pixel:
#for(wt in 1:nWT)cat(prec.wt.sum.norm[23,47,wt,],"\n") # stampa la tabella per Excel dei contributi del Ip02 per il pixel corrisp.alla serie di Valencia
#for(wt in 1:nWT)cat(prec.wt.sum.norm[26,3,wt,],"\n") # stampa la tabella per Excel dei contributi del Ip02 per il pixel corrisp.alla serie di Lisbona
#for(mese in 1:12)cat(as.numeric(round(100*prec.WT.data[[mese]]@data[2167,5:30],2)),"\n") # stampa la tabella dei contributi del modello basato su Mopredas per la stazione di Valencia (devi caricare il file .RData che si riferisce all'articolo 1)

# per ogni pixel, WT e mese, calcola la pdf delle piogge giornaliere:
prec[10,10,righe.wt[[mese*100+wt]]]
hist(prec[10,10,righe.wt[[mese*100+wt]]],20,freq=F,main=paste(WTs.type[wt],"during",nome.mese[mese]))

# # salva un file con il database Ip02 convertito in mensili e nel formato per la matrice int.dati per applicare il modello di regressione:
# # per ogni mese e ANNO, calcola la somma dei grid di prec. per tutto il periodo per passare ai valori mensili anno per anno:
# prec.sum.mes<-array(0,c(n.lat,n.lon,12,y.tot),dimnames=list(rev(lat),lon,nome.mese.short,y.start:y.end)) # array con i grid somma della prec. mensile (lat/lon/mese) occhio a non inizializzarlo a NA se no non fa la somma!!!
# #righe<-list();for(mese in 1:12)righe[[mese]]<- which(WTs$Month==mese) # lista di 12 elenchi, uno per ogni mese, con le righe di WTs (ovvero i giorni) appartenenti a quel mese in tutto il periodo
# for(y in y.start:y.end){for(m in 1:12){for(d in which(WTs$Month==m & WTs$Year==y,arr.ind=T))prec.sum.mes[,,m,y-y.start+1]<-prec.sum.mes[,,m,y-y.start+1]+prec[,,d]}}
# # dato che l'Ip02 manca della colonna di pixel corrisp.a lon=3.6, che invece in Mopredas e' presente, percio' lo aggiungo al posto dei pixel con lon=4.4 (che in mopredas non ci sono), che li tolgo
# temp<-melt(prec.sum.mes,varnames=c("LAT","LON","MONTH","YEAR"))
# ss<-which(temp$LON==4.4) # file corrisp.ai pixel di mare con lon=4.4
# temp$lon[ss]=3.6 # i pixel con lon=4.4 passano ad avere lon=3.6
# temp2<-dcast(temp,LON+LAT+YEAR~MONTH)
# # riordina i mesi perche' dcast li mette in ordine alfabetico!!!
# temp3<-temp2[,c(1:3,match(nome.mese.short,names(temp2)))]
# # ordina temp prima per LAT decrescente e poi per LON, in modo che l'ordine sia quello da in alto a sinistra del grid andando verso destra:
# temp3<-temp3[order(temp3[,3],temp3[,2]),]
# temp3<-temp3[order(temp3[,2],decreasing=T),]
# temp3<-temp3[order(temp3[,3]),]
# npix<-rep(1:(n.lon*n.lat),y.tot)
# temp4<-cbind(npix,temp3[,3:15])
# write.table(temp4,"C:/nicola/precipitaciones/weather_types/Ip02/Database_IBERIA_0.2/Iberia_0,2_en_mensuales.txt",quote=FALSE,row.names=FALSE,col.names=FALSE)

# Analisi di Ricardo:
prec.mean<-apply(prec,3,mean,na.rm=T) # precipitazione giornaliera media per tutti i pixel della penisola iberica
days.inv<-days.inv.SW<-days.inv.W<-days.inv.C<-list() # per ogni anno elenca i giorni invernali (D-G-F-M)
prec.mean.inv<-prec.mean.inv.SW<-prec.mean.inv.W<-prec.mean.inv.C<-n.days<-c()
for(dd in 1951:2003){ # il 1950 no perche gli manca il dicembre del 1949 per costruire la serie invernale)
	days.inv[[dd-1950]]<-c(which(WTs$Year==(dd-1) & WTs$Month==12),which(WTs$Year==dd & WTs$Month<=3))
	days.inv.SW[[dd-1950]]<-c(which(WTs$Year==(dd-1) & WTs$Month==12 & WTs$WT==5),which(WTs$Year==dd & WTs$Month<=3 & WTs$WT==5))
	days.inv.W[[dd-1950]]<-c(which(WTs$Year==(dd-1) & WTs$Month==12 & WTs$WT==6),which(WTs$Year==dd & WTs$Month<=3 & WTs$WT==6))
	days.inv.C[[dd-1950]]<-c(which(WTs$Year==(dd-1) & WTs$Month==12 & WTs$WT==9),which(WTs$Year==dd & WTs$Month<=3 & WTs$WT==9))
	n.days[dd-1950]<-length(days.inv.SW[[dd-1950]])+length(days.inv.W[[dd-1950]])+length(days.inv.C[[dd-1950]]) #num.giorni app.a SW, W o C
	
	prec.mean.inv[dd-1950]<-mean(prec.mean[days.inv[[dd-1950]]],na.rm=T)
	prec.mean.inv.SW[dd-1950]<-mean(prec.mean[days.inv.SW[[dd-1950]]],na.rm=T)
	prec.mean.inv.W[dd-1950]<-mean(prec.mean[days.inv.W[[dd-1950]]],na.rm=T)
	prec.mean.inv.C[dd-1950]<-mean(prec.mean[days.inv.C[[dd-1950]]],na.rm=T)
	if(length(days.inv.SW[[dd-1950]])==0)prec.mean.inv.SW[dd-1950]<-0
	if(length(days.inv.W[[dd-1950]])==0)prec.mean.inv.W[dd-1950]<-0
	if(length(days.inv.C[[dd-1950]])==0)prec.mean.inv.C[dd-1950]<-0
	
}
output<-cbind(1951:2003,prec.mean.inv,prec.mean.inv.SW,prec.mean.inv.W,prec.mean.inv.C,n.days)

for(dd in 1951:2003){ 
}
 
########################################### CREAZIONE CARTOGRAFIA ###########################################################################
# crea un grid a 0.20 gradi dec che si sovrapponga a tutta la Penisola Iberica:
gt = GridTopology(cellcentre.offset = c(xmin.box,ymin.box), cellsize = c(pixel.size,pixel.size), cells.dim = c(num.x.pixels,num.y.pixels))
grd = SpatialGrid(gt)
proj4string(grd) <- coord.system
#summary(grd);plot(IpPoly);plot(grd,add=T) # visualizza il grid sovrapposto alla IP

#IpPoly<- readShapePoly(IpPoly.geograf)
#proj4string(IpPoly) <- CRS("+proj=longlat +datum=WGS84") 
#my.polygon<-list('sp.polygons',IpPoly,fill='transparent',first=F) # first=FALSE gli dice di NON disegnare il poligono per primo # altre opzioni di list: fill=0, lwd=3, lty=2

IpIslesPoly<- readShapePoly(IpIslesPoly.geograf)
proj4string(IpIslesPoly) <- CRS("+proj=longlat +datum=WGS84") 
my.polygon<-list('sp.polygons',IpIslesPoly,fill='transparent',first=F) # first=FALSE gli dice di NON disegnare il poligono per primo # altre opzioni di list: fill=0, lwd=3, lty=2

# crea un grid vuoto da usare come plantilla per disegnare le mappe
grid.vuoto<-SpatialGridDataFrame(grd, as.data.frame(rep(NA,n.pixels)), proj4string = CRS("+proj=longlat +datum=WGS84") )

# crea un grid con stessa area di grd ma risoluzione X volte piu'alta per risolvere il problema delle sbavature sui bordi della penisola:
multiply=2 # fattore di moltiplicazione della resoluzione per ogni coordinata (va bene qualsiasi numero intero)
gt.high<-GridTopology(cellcentre.offset = c(xmin.box-pixel.size/2+pixel.size/(2*multiply),ymin.box-pixel.size/2+pixel.size/(2*multiply)), cellsize = c(pixel.size/multiply,pixel.size/multiply), cells.dim = c(num.x.pixels*multiply,num.y.pixels*multiply))
grd.high = SpatialGrid(gt.high);proj4string(grd.high) <- coord.system
grid.high.vuoto<-SpatialGridDataFrame(grd.high, as.data.frame(rep(NA,n.pixels*(multiply^2))), proj4string = CRS("+proj=longlat +datum=WGS84") )
sea.high.pixels<-which(is.na(overlay(grd.high,IpIslesPoly))==T) # seleziona i pixel del grid.high fuori dal poligono della IP e li mette a NA in modo che non li disegni nella mappa finale: (devo farlo cosi'perche'layout non funziona)
land.high.pixels<-(1:n.pixels*multiply)[-sea.high.pixels]

# layout mappe:
my.text<-list("sp.text", c(3,36.8), "400 km",cex=.4,which=12) # in futuro riadattalo anche per le mappe in cord.geografiche
my.scale.bar<-list("SpatialPolygonsRescale", layout.scale.bar(0.03), offset = c(-0.3,36.2),scale = 4, which=12,fill=c("transparent","black"))
my.north.arrow<-list("SpatialPolygonsRescale", offset = c(4,36.2), scale = 1,layout.north.arrow(type=2),size=1,which=12) # per disegnare l'altra freccia del nord meno orribile, quella senza la N dentro la freccia
my.north<-list("sp.text", c(4.15,37.6), "N",cex=.5,which=12) # which serve per aggiungere il testo solo nel pannello numero 6 !!!
my.layout<-list(my.polygon)
my.layout<-list(my.polygon,my.text,my.scale.bar,my.north.arrow,my.north)

# visualizza una composizione con la climatologia mensile (senza considerare i WTs):
prec.clim.mappa<-grid.vuoto
for(mese in 1:12)prec.clim.mappa@data[[nome.mese.short[mese]]]<-as.vector(t(prec.clim[,,mese]))
my.names<-nome.mese
my.title<-"Monthly Prec.Climatology Ip02 1950-2003"
my.prec.levels<- c(seq(0,50,1),seq(52.5,150,2.5),seq(155,200,5),seq(210,290,20),500)
my.prec.levels.in.leyend<-c(0,25,50,75,100,150,200,300,400,500)
my.map<-spplot(prec.clim.mappa,nome.mese.short,main=my.title,par.settings = standard.theme(color = FALSE),as.table=TRUE,layout=c(3,4),
	at=my.prec.levels,col.regions=rev(jet.colors(10000)),sp.layout=my.layout,cex=.5,names.attr=my.names,legendEntries=my.labels,colorkey=list(space="right",width=0.5,height=1,labels=list(at=my.prec.levels.in.leyend)))
jpeg("C:/nicola/precipitaciones/weather_types/mapas/6) composiciones_EMULATE_y_IP02/Climatology_Ip02_1950-2003.jpg",width=590,height=616,quality=100);print(my.map);dev.off() # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.

# Numero di WTs con contributo percentuale >=X%
soglia=1
num.wt<-array(0,c(n.lat,n.lon,12),dimnames=list(rev(lat),lon,nome.mese))
temp<-prec.wt.sum.norm
ss<-which(prec.wt.sum.norm>=soglia)
tt<-which(prec.wt.sum.norm<soglia)
temp[ss]<-1;temp[tt]<-0
for(mese in 1:12){for(wt in 1:nWT){num.wt[,,mese]<-num.wt[,,mese]+temp[,,wt,mese]}}
num.wt.mappa<-grid.vuoto
for(mese in 1:12)num.wt.mappa@data[[nome.mese.short[mese]]]<-as.vector(t(num.wt[,,mese]))
my.names<-nome.mese
my.title<-paste("Number of WTs with Perc.Contribution >",soglia,"%",sep="")
my.prec.levels<- seq(1,20,1)
my.prec.levels.in.leyend<-my.prec.levels #seq(1,20,1)
my.map<-spplot(num.wt.mappa,nome.mese.short,main=my.title,par.settings = standard.theme(color = FALSE),as.table=TRUE,layout=c(3,4),
	at=my.prec.levels,col.regions=rev(jet.colors(10000)),sp.layout=my.layout,cex=.5,names.attr=my.names,legendEntries=my.labels,colorkey=list(space="right",width=0.5,height=1,labels=list(at=my.prec.levels.in.leyend)))
print(my.map)
jpeg("C:/nicola/precipitaciones/weather_types/mapas/6) composiciones_EMULATE_y_IP02/Climatology_Ip02_1950-2003.jpg",width=590,height=616,quality=100);print(my.map);dev.off() # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.

# mappa di quanti WTs servono per arrivare all'X% di prec.mensile
soglia=70
num.wt<-array(NA,c(n.lat,n.lon,12),dimnames=list(rev(lat),lon,nome.mese))
for(mese in 1:12){for(i in 1:n.lat){for (j in 1:n.lon){
	if(!is.na(prec.wt.sum.norm[i,j,1,mese])){
		temp<-prec.wt.sum.norm[i,j,,mese] # vettore con i contributi percentuali di ogni tipo di tempo per quel pixel e mese
		temp<-sort(temp,decreasing=TRUE)
		temp<-cumsum(temp)
		num.wt[i,j,mese]<-which(temp>soglia)[1]
	} else {num.wt[i,j,mese]=NA}
}}}
num.wt.mappa<-grid.vuoto;for(mese in 1:12)num.wt.mappa@data[[nome.mese.short[mese]]]<-as.vector(t(num.wt[,,mese]))
my.names<-nome.mese
my.title<-paste("Number of WTs with Sum of Percentual Contribution = ",soglia,"%",sep="")
my.prec.levels<- seq(1,max(num.wt,na.rm=T),1)
my.prec.levels.in.leyend<-my.prec.levels #seq(1,20,1)
my.map<-spplot(num.wt.mappa,nome.mese.short[c(12,1:11)],main=my.title,par.settings = standard.theme(color = FALSE),as.table=TRUE,layout=c(3,4),
	at=my.prec.levels,col.regions=rev(jet.colors(10000)),sp.layout=my.layout,cex=.5,names.attr=my.names[c(12,1:11)],legendEntries=my.labels,colorkey=list(space="right",width=0.5,height=1,labels=list(at=my.prec.levels.in.leyend)))
print(my.map)
jpeg("C:/nicola/precipitaciones/weather_types/mapas/6) composiciones_EMULATE_y_IP02/Climatology_Ip02_1950-2003.jpg",width=590,height=616,quality=100);print(my.map);dev.off() # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.


# mappa della soglia (in mm) del percentile XX% fissato:
p=0.90 # scegli un percentile gia' presente nel vettore percentile
n.percentile<-which(percentile==p)
upper.limit=max(percentiles[,,,n.percentile],na.rm=T) #2.5 per il percentile 0.10
percentiles.mappa<-grid.vuoto;for(mese in 1:12)percentiles.mappa@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(percentiles[,,mese,n.percentile],upper.limit)))
my.names<-nome.mese
my.title<-paste(100*percentile[n.percentile],"th Percentile",sep="")
my.prec.levels<-seq(1,upper.limit,0.1) # seq(1,max(percentiles,na.rm=T),0.1) # nota che la soglia e'sempre >1 mm per definizione di percentile di pioggia
my.prec.levels.in.leyend<-my.prec.levels #seq(1,max(percentiles,na.rm=T),0.1)
my.map<-spplot(percentiles.mappa,nome.mese.short[c(12,1:11)],main=my.title,par.settings = standard.theme(color = FALSE),as.table=TRUE,layout=c(3,4),
	at=my.prec.levels,col.regions=rev(jet.colors(10000)),sp.layout=my.layout,cex=.5,names.attr=my.names[c(12,1:11)],legendEntries=my.labels,colorkey=list(space="right",width=0.5,height=1,labels=list(at=my.prec.levels.in.leyend)))
print(my.map)

# mappa indice RXXp (numero di giorni al mese superiori al percentile XX):
p=0.05 # scegli il percentile corrispondente all'indice RXXp da mappare

n.percentile<-which(percentile==p)
upper.limit=max(n.days.above.medio[,,,n.percentile],na.rm=T) #2.5 per il percentile 0.10
my.var.map<-grid.vuoto;for(mese in 1:12)my.var.map@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(n.days.above.medio[,,mese,n.percentile],upper.limit)))
my.names<-nome.mese
my.title<-paste("R",100*p,"p",sep="")
#my.prec.levels<-seq(0,max(n.days.above.medio,na.rm=T),0.1) # seq(1,max(percentiles,na.rm=T),0.1)
my.prec.levels<-seq(0,0.1+max(n.days.above.medio[,,,n.percentile],na.rm=T),0.1)
my.prec.levels.in.leyend<-my.prec.levels #seq(1,max(percentiles,na.rm=T),0.1)
my.map<-spplot(my.var.map,nome.mese.short[c(12,1:11)],main=my.title,par.settings = standard.theme(color = FALSE),as.table=TRUE,layout=c(3,4),
	at=my.prec.levels,col.regions=rev(jet.colors(10000)),sp.layout=my.layout,cex=.5,names.attr=my.names[c(12,1:11)],legendEntries=my.labels,colorkey=list(space="right",width=0.5,height=1,labels=list(at=my.prec.levels.in.leyend)))
#print(my.map)
jpeg(paste("C:/nicola/precipitaciones/weather_types/Ip02/mapa ",my.title,".jpg",sep=""),width=600,height=650,quality=100);print(my.map);dev.off()


# visualizza una composizione per ogni WT con il suo contributo medio mensile alla prec, cioe' visualizza la "climatologia dei WT"
my.names<-nome.mese
my.cuts<- c(seq(1,30,1),35,40,50,70,100)^0.5 # fa la radice quadrata per diminuiere le differenze tra i valori piu' alti e quelli piu' bassi in modo che non ci sia un colore che domina la legenda; occhio che funziona solo se la variabile da rappresentare non e' negativa!!!
my.labels=c(1,10,20,50,100) # i numeri che vuoi vedere visualizzati nella legenda, anche se nella mappa si visualizzano in realta' le loro radici
my.cuts.in.leyend<-my.labels^0.5 
lx=0.25;ly=0.25  # lunghezza orizzontale e verticale di un mapa piccolo
g1=0.74;g3=0.53;g8=0.32;g5=0.11 # altezza prima/seconda/terza/quarta fila

prec.wt.clim.mappa<-list()
for(wt in 1:nWT){ # cicla su tutti i WTs
	prec.wt.clim.mappa[[wt]]<-grid.vuoto
	for(mese in 1:12)prec.wt.clim.mappa[[wt]]@data[[nome.mese.short[mese]]]<-as.vector(t(prec.wt.clim[,,wt,mese]))^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)

	my.map<-list()
	for(mese in 1:12){
		my.main<-list(label=nome.mese[mese],cex=1)
		my.map[[mese]]<-spplot(prec.wt.clim.mappa[[wt]],nome.mese.short[mese],main=my.main,par.settings = standard.theme(color = FALSE),
			at=my.cuts,col.regions=rev(jet.colors3(10000)),sp.layout=my.layout,cex=.5,names.attr=my.names[mese],legendEntries=my.labels,colorkey=FALSE)
	}

	# sotto la mappa di agosto aggiunge la legenda:
	mese=8;my.main<-list(label=nome.mese[mese],cex=1)
	my.map[[mese]]<-spplot(prec.wt.clim.mappa[[wt]],nome.mese.short[mese],main=my.main,par.settings = standard.theme(color = FALSE),
		at=my.cuts,col.regions=rev(jet.colors3(10000)),sp.layout=my.layout,cex=.5,names.attr=my.names[mese],colorkey=list(space="bottom",width=0.5,height=3,labels=list(at=my.cuts.in.leyend,labels=my.labels)))
		
	#jpeg(paste("C:/nicola/precipitaciones/weather_types/mapas/14) composiciones_IP02_WTs_climatology_leyenda_bonita/",WTs.type[wt],".jpg",sep=""),width=590,height=616,quality=100) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.
    tiff(paste("C:/nicola/precipitaciones/weather_types/mapas/14) composiciones_IP02_WTs_climatology_leyenda_bonita/",WTs.type[wt],".tif",sep=""),width=590,height=616,quality=100) # altri formati possibili per salvare il grafico sono: pdf, bmp,jpeg, tiff.	
	textplot(paste(WTs.type[wt],"Climatology > 1 mm") ,cex=1.5,halign="center",valign="center",mar=c(0,0,0,0))
	print(my.map[[1]], position= c(0,g1,0+lx,g1+ly),more=T) # fai ?print.trellis per la spiegazione di come dividere lo schermo con gli spplot
	print(my.map[[2]], position= c(0.25,g1,0.25+lx,g1+ly),more=T) # (xmin, ymin, xmax, ymax)
	print(my.map[[3]], position= c(0.50,g1,0.50+lx,g1+ly),more=T) 
	print(my.map[[4]], position= c(0.75,g1,0.75+lx,g1+ly),more=T) 
	print(my.map[[5]], position= c(0.75,g3,0.75+lx,g3+ly),more=T)
	print(my.map[[6]], position= c(0.75,g8,0.75+lx,g8+ly),more=T)
	print(my.map[[7]], position= c(0.75,g5,0.75+lx,g5+ly),more=T) 
	print(my.map[[8]], position= c(0.50,g5-0.038,0.50+lx,g5+ly),more=T)
	print(my.map[[9]], position= c(0.25,g5,0.25+lx,g5+ly),more=T)
	print(my.map[[10]], position= c(0,g5,0+lx,g5+ly),more=T) 
	print(my.map[[11]], position= c(0,g8,0+lx,g8+ly),more=T)
	print(my.map[[12]], position= c(0,g3,0+lx,g3+ly),more=T)
	dev.off()
} # chiude il for su wt

# visualizza per ogni WT la sua climatologia mensile (senza composizione):
upper.limit=40 # limite massimo sopra il quale tutti i dati vengono ridotti a questo numero 
my.cuts<- seq(1,upper.limit,1) #^0.5 # fa la radice quadrata per diminuiere le differenze tra i valori piu' alti e quelli piu' bassi in modo che non ci sia un colore che domina la legenda; occhio che funziona solo se la variabile da rappresentare non e' negativa!!!
my.labels=c("1 mm","10 mm","20 mm","30 mm",paste(upper.limit,"mm")) # i numeri che vuoi vedere visualizzati nella legenda, anche se nella mappa si visualizzano in realta' le loro radici
my.cuts.in.leyend<-c(1,10,20,30,upper.limit) #^0.5 # posizione tacche della legenda dove si visualizzano i my.labels
my.color=rev(jet.colors3(1000))
my.names<-nome.mese
prec.wt.clim.mappa<-list()
for(wt in 1:nWT){ # cicla su tutti i WTs
	my.main<-paste(WTs.type.long[wt],"Climatology")  # inserisci qui il titolo del grafico
	my.var<-prec.wt.clim # inserisci qui la variabile da mappare (dev'essere un array del tipo [lat,lon,wt,mese], se e' diverso modica la riga sopra l'spplot)
	my.grid<-grid.vuoto
	for(mese in 1:12)my.grid@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	my.map<-spplot(my.grid,nome.mese.short,main=my.main,par.settings = standard.theme(color = FALSE),layout=c(3,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,cex=.5,names.attr=my.names,colorkey=list(space="bottom",width=0.5,height=1,labels=list(at=my.cuts.in.leyend,labels=my.labels)))
	# disegna la stessa mappa ma senza sbavature:
	my.grid.high<-grid.high.vuoto;my.var.high<-array(NA,c(dim(my.var)[1]*multiply,dim(my.var)[2]*multiply,dim(my.var)[3],dim(my.var)[4]));for(i in 1:dim(my.var.high)[1]){for(j in 1:dim(my.var.high)[2])my.var.high[i,j,wt,]<-my.var[ceiling(i/multiply),ceiling(j/multiply),wt,]}
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var.high[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]][sea.high.pixels]<-NA # elimina i pixel del grid fuori dalla penisola iberica e dalle isle
	my.map<-spplot(my.grid.high,nome.mese.short,main=my.main,par.settings = standard.theme(color = FALSE),layout=c(3,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,cex=.5,names.attr=my.names,colorkey=list(space="bottom",width=0.5,height=1,labels=list(at=my.cuts.in.leyend,labels=my.labels)))		
	jpeg(paste("C:/nicola/precipitaciones/weather_types/mapas/16) Ip02_WTs_climatology_over_1_mm_leyenda_perfecta/",WTs.type[wt],".jpg",sep=""),width=590,height=616,quality=100);print(my.map);dev.off()
}
prec.wt.clim.medio<-array(NA,c(12,nWT),dimnames=list(nome.mese,WTs.type))  # (tabla) per ogni WT e mese calcola la somma su tutti i pixel del contributo assoluto (somma in mm) alla prec.tot:
for(mese in 1:12){for(wt in 1:nWT)prec.wt.clim.medio[mese,wt]<-mean(prec.wt.clim[,,wt,mese],na.rm=T)} 
tab.contrib.ass<-t(round(prec.wt.clim.medio,1)) # arrotonda e trasforma i valori in percentuali
tab.contrib.ass<-rbind(tab.contrib.ass,round(colSums(t(prec.wt.clim.medio)),1))
tab.contrib.ass<-cbind(tab.contrib.ass,round(rowMeans(tab.contrib.ass),1))

# visualizza per ogni WT il suo contributo relativo mensile (senza composizione):
upper.limit=40 # limite massimo sopra il quale tutti i dati vengono ridotti a questo numero 
my.cuts<- seq(1,upper.limit,1) #^0.5 # fa la radice quadrata per diminuiere le differenze tra i valori piu' alti e quelli piu' bassi in modo che non ci sia un colore che domina la legenda; occhio che funziona solo se la variabile da rappresentare non e' negativa!!!
my.labels=c("1%","10%","20%","30%",paste(upper.limit,"%",sep="")) # i numeri che vuoi vedere visualizzati nella legenda, anche se nella mappa si visualizzano in realta' le loro radici
my.cuts.in.leyend<-c(1,10,20,30,upper.limit) #^0.5 # posizione tacche della legenda dove si visualizzano i my.labels
my.color=rev(jet.colors7(1000))
my.names<-nome.mese
for(wt in 1:nWT){ # cicla su tutti i WTs
	my.main<-paste(WTs.type.long[wt],"Relative contribute") # inserisci qui il titolo del grafico
	my.var=prec.wt.sum.norm # inserisci qui la variabile da mappare (dev'essere un array del tipo [lat,lon,wt,mese], se e' diverso modica la riga sopra l'spplot)
	my.grid<-grid.vuoto
	for(mese in 1:12)my.grid@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	my.map<-spplot(my.grid,nome.mese.short,main=my.main,par.settings = standard.theme(color = FALSE),layout=c(3,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,cex=.5,names.attr=my.names,colorkey=list(space="bottom",width=0.5,height=1,labels=list(at=my.cuts.in.leyend,labels=my.labels)))
	# disegna la stessa mappa ma senza sbavature:
	my.grid.high<-grid.high.vuoto;my.var.high<-array(NA,c(dim(my.var)[1]*multiply,dim(my.var)[2]*multiply,dim(my.var)[3],dim(my.var)[4]));for(i in 1:dim(my.var.high)[1]){for(j in 1:dim(my.var.high)[2])my.var.high[i,j,wt,]<-my.var[ceiling(i/multiply),ceiling(j/multiply),wt,]}
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var.high[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]][sea.high.pixels]<-NA # elimina i pixel del grid fuori dalla penisola iberica e dalle isle
	my.map<-spplot(my.grid.high,nome.mese.short,main=my.main,par.settings = standard.theme(color = FALSE),layout=c(3,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,cex=.5,names.attr=my.names,colorkey=list(space="bottom",width=0.5,height=1,labels=list(at=my.cuts.in.leyend,labels=my.labels)))		
	jpeg(paste("C:/nicola/precipitaciones/weather_types/mapas/17) Ip02_WTs_relative_contrib_over_1_percent/",WTs.type[wt],".jpg",sep=""),width=590,height=616,quality=100);print(my.map);dev.off()
}
prec.wt.sum.norm.medio<-array(NA,c(nWT,12),dimnames=list(WTs.type,nome.mese)) # (tabla) per ogni WT e mese calcola la somma su tutti i pixel del contributo relativo alla prec.tot:
for(mese in 1:12){for(wt in 1:nWT)prec.wt.sum.norm.medio[wt,mese]<-mean(prec.wt.sum.norm[,,wt,mese],na.rm=T)} 
tab.contrib.rel<-round(prec.wt.sum.norm.medio,1) # arrotonda e trasforma i valori in percentuali
tab.contrib.rel<-rbind(tab.contrib.rel,colSums(tab.contrib.rel))  


# visualizza per ogni WT la sua intensita'mensile (senza composizione):
upper.limit=20 # limite massimo sopra il quale tutti i dati vengono ridotti a questo numero 
my.cuts<- seq(1,upper.limit,1) #^0.5 # fa la radice quadrata per diminuire le differenze tra i valori piu' alti e quelli piu' bassi in modo che non ci sia un colore che domina la legenda; occhio che funziona solo se la variabile da rappresentare non e' negativa!!!
my.labels=c("1 mm/day","5 mm/day","10 mm/day","15 mm/day",paste(upper.limit," mm/day",sep="")) # i numeri che vuoi vedere visualizzati nella legenda, anche se nella mappa si visualizzano in realta' le loro radici
my.cuts.in.leyend<-c(1,5,10,15,upper.limit) #^0.5 # posizione tacche della legenda dove si visualizzano i my.labels
my.color=rev(jet.colors3(1000))
my.names<-nome.mese
for(wt in 1:nWT){ # cicla su tutti i WTs
	my.main<-paste(WTs.type.long[wt],"Prec.Intensity") # inserisci qui il titolo del grafico
	my.var=prec.wt.int # inserisci qui la variabile da mappare (dev'essere un array del tipo [lat,lon,mese], se e' diverso modica la riga sopra l'spplot)
	my.grid<-grid.vuoto
	for(mese in 1:12)my.grid@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	my.map<-spplot(my.grid,nome.mese.short,main=my.main,par.settings = standard.theme(color = FALSE),layout=c(3,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,cex=.5,names.attr=my.names,colorkey=list(space="bottom",width=0.5,height=1,labels=list(at=my.cuts.in.leyend,labels=my.labels)))
	# disegna la stessa mappa ma senza sbavature:
	my.grid.high<-grid.high.vuoto;my.var.high<-array(NA,c(dim(my.var)[1]*multiply,dim(my.var)[2]*multiply,dim(my.var)[3],dim(my.var)[4]));for(i in 1:dim(my.var.high)[1]){for(j in 1:dim(my.var.high)[2])my.var.high[i,j,wt,]<-my.var[ceiling(i/multiply),ceiling(j/multiply),wt,]}
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var.high[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]][sea.high.pixels]<-NA # elimina i pixel del grid fuori dalla penisola iberica e dalle isle
	my.map<-spplot(my.grid.high,nome.mese.short,main=my.main,par.settings = standard.theme(color = FALSE),layout=c(3,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,cex=.5,names.attr=my.names,colorkey=list(space="bottom",width=0.5,height=1,labels=list(at=my.cuts.in.leyend,labels=my.labels)))		
	jpeg(paste("C:/nicola/precipitaciones/weather_types/mapas/18) Ip02_WTs_prec_intensity/",WTs.type[wt],".jpg",sep=""),width=590,height=616,quality=100);print(my.map);dev.off()
}
prec.wt.int.medio<-array(NA,c(nWT,12),dimnames=list(WTs.type.long,nome.mese))
for(mese in 1:12){for(wt in 1:nWT)prec.wt.int.medio[wt,mese]<-mean(prec.wt.int[,,wt,mese],na.rm=T)} 
prec.wt.int.medio[which(is.nan(prec.wt.int.medio))]<-0 # mette a zero i mesi senza giorni di pioggia per quel WT in tutto il periodo
prec.wt.int.medio.tab<-round(rbind(prec.wt.int.medio,colSums(prec.wt.int.medio)),1)
prec.wt.int.medio.tab<-cbind(prec.wt.int.medio.tab,round(rowMeans(prec.wt.int.medio.tab),1)) # (tabla) per ogni WT e mese calcola la somma su tutti i pixel della intensita'di prec: 


# visualizza per ogni WT la sua efficienza mensile (senza composizione):
upper.limit=100 # limite massimo sopra il quale tutti i dati vengono ridotti a questo numero 
my.cuts<- seq(1,upper.limit,1) #^0.5 # fa la radice quadrata per diminuire le differenze tra i valori piu' alti e quelli piu' bassi in modo che non ci sia un colore che domina la legenda; occhio che funziona solo se la variabile da rappresentare non e' negativa!!!
my.labels=c("1%","25%","50%","75%",paste(upper.limit,"%",sep="")) # i numeri che vuoi vedere visualizzati nella legenda, anche se nella mappa si visualizzano in realta' le loro radici
my.cuts.in.leyend<-c(1,25,50,75,upper.limit) #^0.5 # posizione tacche della legenda dove si visualizzano i my.labels
my.color=rev(jet.colors8(1000))
my.names<-nome.mese
for(wt in 1:nWT){ # cicla su tutti i WTs
	my.main<-paste(WTs.type.long[wt],"Prec.Efficiency") # inserisci qui il titolo del grafico
	my.var=prec.wt.eff# inserisci qui la variabile da mappare (dev'essere un array del tipo [lat,lon,mese], se e' diverso modica la riga sopra l'spplot)
	my.grid<-grid.vuoto
	for(mese in 1:12)my.grid@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	my.map<-spplot(my.grid,nome.mese.short,main=my.main,par.settings = standard.theme(color = FALSE),layout=c(3,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,cex=.5,names.attr=my.names,colorkey=list(space="bottom",width=0.5,height=1,labels=list(at=my.cuts.in.leyend,labels=my.labels)))
	# disegna la stessa mappa ma senza sbavature:
	my.grid.high<-grid.high.vuoto;my.var.high<-array(NA,c(dim(my.var)[1]*multiply,dim(my.var)[2]*multiply,dim(my.var)[3],dim(my.var)[4]));for(i in 1:dim(my.var.high)[1]){for(j in 1:dim(my.var.high)[2])my.var.high[i,j,wt,]<-my.var[ceiling(i/multiply),ceiling(j/multiply),wt,]}
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var.high[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]][sea.high.pixels]<-NA # elimina i pixel del grid fuori dalla penisola iberica e dalle isle
	my.map<-spplot(my.grid.high,nome.mese.short,main=my.main,par.settings = standard.theme(color = FALSE),layout=c(3,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,cex=.5,names.attr=my.names,colorkey=list(space="bottom",width=0.5,height=1,labels=list(at=my.cuts.in.leyend,labels=my.labels)))		
	jpeg(paste("C:/nicola/precipitaciones/weather_types/Ip02/19) Ip02_WTs_prec_efficiency/",WTs.type[wt],".jpg",sep=""),width=590,height=616,quality=100);print(my.map);dev.off()
}
prec.wt.eff.medio<-array(NA,c(nWT,12),dimnames=list(WTs.type.long,nome.mese))
for(mese in 1:12){for(wt in 1:nWT)prec.wt.eff.medio[wt,mese]<-mean(prec.wt.eff[,,wt,mese],na.rm=T)} 
prec.wt.eff.medio[which(is.nan(prec.wt.eff.medio))]<-0 # mette a zero i mesi senza giorni di pioggia per quel WT in tutto il periodo
prec.wt.eff.medio.tab<-round(cbind(prec.wt.eff.medio,rowMeans(prec.wt.eff.medio)),1) # (tabla) per ogni WT e mese calcola la somma su tutti i pixel della efficienza dei prec: 


# grafico di tutti gli indici solo per i mesi di gennaio, aprile, luglio e ottobre (1,4,7, e 10):
my.period<-c(1,4,7,10) # seleziona i mesi da mappare

my.text<-list("sp.text", c(3,36.8), "400 km",cex=.4,which=4) # in futuro riadattalo anche per le mappe in cord.geografiche
my.scale.bar<-list("SpatialPolygonsRescale", layout.scale.bar(0.03), offset = c(-0.3,36.2),scale = 4, which=4,fill=c("transparent","black"))
my.north.arrow<-list("SpatialPolygonsRescale", offset = c(4,36.2), scale = 1,layout.north.arrow(type=2),size=1,which=4) # per disegnare l'altra freccia del nord meno orribile, quella senza la N dentro la freccia
my.north<-list("sp.text", c(4.15,37.6), "N",cex=.5,which=4) # which serve per aggiungere il testo solo nel pannello numero 6 !!!
my.layout<-list(my.polygon)
my.layout2<-list(my.polygon,my.text,my.scale.bar,my.north.arrow,my.north)
for(wt in 1:nWT){ # cicla su tutti i WTs
	# visualizza per ogni WT la sua climatologia mensile (senza composizione):
	upper.limit=40 # limite massimo sopra il quale tutti i dati vengono ridotti a questo numero 
	my.cuts<- seq(1,upper.limit,1) #^0.5 # fa la radice quadrata per diminuiere le differenze tra i valori piu' alti e quelli piu' bassi in modo che non ci sia un colore che domina la legenda; occhio che funziona solo se la variabile da rappresentare non e' negativa!!!
	my.labels=c("1 mm","10 mm","20 mm","30 mm",paste(upper.limit,"mm")) # i numeri che vuoi vedere visualizzati nella legenda, anche se nella mappa si visualizzano in realta' le loro radici
	my.cuts.in.leyend<-c(1,10,20,30,upper.limit) #^0.5 # posizione tacche della legenda dove si visualizzano i my.labels
	my.color=rev(jet.colors15(1000))
	my.names<-nome.mese[my.period]
	prec.wt.clim.mappa<-list()
	my.main<-list(label="Mean Precipitation",cex=1,vjust=1) # vjust sposta il titolo un piu'in basso, vedi ?xy.plot sotto la descrizione di main
	my.var<-prec.wt.clim # inserisci qui la variabile da mappare (dev'essere un array del tipo [lat,lon,wt,mese], se e' diverso modica la riga sopra l'spplot)
	# disegna la stessa mappa ma senza sbavature:
	my.grid.high<-grid.high.vuoto;my.var.high<-array(NA,c(dim(my.var)[1]*multiply,dim(my.var)[2]*multiply,dim(my.var)[3],dim(my.var)[4]));for(i in 1:dim(my.var.high)[1]){for(j in 1:dim(my.var.high)[2])my.var.high[i,j,wt,]<-my.var[ceiling(i/multiply),ceiling(j/multiply),wt,]}
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var.high[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]][sea.high.pixels]<-NA # elimina i pixel del grid fuori dalla penisola iberica e dalle isle
	my.map1<-spplot(my.grid.high,nome.mese.short[my.period],main=my.main,par.settings = standard.theme(color = FALSE),layout=c(1,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,names.attr=my.names,par.strip.text = list(cex = .9),colorkey=list(space="bottom",width=0.5,height=.8,labels=list(at=my.cuts.in.leyend,labels=my.labels,cex=.6)))		

	# visualizza per ogni WT il suo contributo relativo mensile (senza composizione):
	upper.limit=40 # limite massimo sopra il quale tutti i dati vengono ridotti a questo numero 
	my.cuts<- seq(1,upper.limit,1) #^0.5 # fa la radice quadrata per diminuiere le differenze tra i valori piu' alti e quelli piu' bassi in modo che non ci sia un colore che domina la legenda; occhio che funziona solo se la variabile da rappresentare non e' negativa!!!
	my.labels=c("1%","10%","20%","30%",paste(upper.limit,"%",sep="")) # i numeri che vuoi vedere visualizzati nella legenda, anche se nella mappa si visualizzano in realta' le loro radici
	my.cuts.in.leyend<-c(1,10,20,30,upper.limit) #^0.5 # posizione tacche della legenda dove si visualizzano i my.labels
	my.color=rev(jet.colors7(1000))
	my.names<-nome.mese[my.period]
	my.main<-list(label="% Contribution",cex=1,vjust=1) # vjust sposta il titolo un piu'in basso, vedi ?xy.plot sotto la descrizione di main
	my.var=prec.wt.sum.norm # inserisci qui la variabile da mappare (dev'essere un array del tipo [lat,lon,wt,mese], se e' diverso modica la riga sopra l'spplot)
	# disegna la stessa mappa ma senza sbavature:
	my.grid.high<-grid.high.vuoto;my.var.high<-array(NA,c(dim(my.var)[1]*multiply,dim(my.var)[2]*multiply,dim(my.var)[3],dim(my.var)[4]));for(i in 1:dim(my.var.high)[1]){for(j in 1:dim(my.var.high)[2])my.var.high[i,j,wt,]<-my.var[ceiling(i/multiply),ceiling(j/multiply),wt,]}
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var.high[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]][sea.high.pixels]<-NA # elimina i pixel del grid fuori dalla penisola iberica e dalle isle
	my.map2<-spplot(my.grid.high,nome.mese.short[my.period],main=my.main,par.settings = standard.theme(color = FALSE),layout=c(1,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,names.attr=my.names,par.strip.text = list(cex = .9),colorkey=list(space="bottom",width=0.5,height=.8,labels=list(at=my.cuts.in.leyend,labels=my.labels,cex=.6)))		
		
	# visualizza per ogni WT la sua intensita'mensile (senza composizione):
	upper.limit=20 # limite massimo sopra il quale tutti i dati vengono ridotti a questo numero 
	my.cuts<- seq(1,upper.limit,1) #^0.5 # fa la radice quadrata per diminuire le differenze tra i valori piu' alti e quelli piu' bassi in modo che non ci sia un colore che domina la legenda; occhio che funziona solo se la variabile da rappresentare non e' negativa!!!
	my.labels=c("1 mm/d","","10 mm/d","",paste(upper.limit," mm/d",sep="")) # i numeri che vuoi vedere visualizzati nella legenda, anche se nella mappa si visualizzano in realta' le loro radici
	my.cuts.in.leyend<-c(1,5,10,15,upper.limit) #^0.5 # posizione tacche della legenda dove si visualizzano i my.labels
	my.color=rev(jet.colors15(1000))
	my.names<-nome.mese[my.period]
	my.main<-list(label="Intensity",cex=1,vjust=1) # vjust sposta il titolo un piu'in basso, vedi ?xy.plot sotto la descrizione di main
	my.var=prec.wt.int # inserisci qui la variabile da mappare (dev'essere un array del tipo [lat,lon,wt,mese], se e' diverso modica la riga sopra l'spplot)
	my.grid<-grid.vuoto
	for(mese in 1:12)my.grid@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	my.map<-spplot(my.grid,nome.mese.short[my.period],main=my.main,par.settings = standard.theme(color = FALSE),layout=c(1,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,cex=.5,names.attr=my.names,colorkey=list(space="bottom",width=0.5,height=.8,labels=list(at=my.cuts.in.leyend,labels=my.labels,cex=.6)))
	# disegna la stessa mappa ma senza sbavature:
	my.grid.high<-grid.high.vuoto;my.var.high<-array(NA,c(dim(my.var)[1]*multiply,dim(my.var)[2]*multiply,dim(my.var)[3],dim(my.var)[4]));for(i in 1:dim(my.var.high)[1]){for(j in 1:dim(my.var.high)[2])my.var.high[i,j,wt,]<-my.var[ceiling(i/multiply),ceiling(j/multiply),wt,]}
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var.high[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]][sea.high.pixels]<-NA # elimina i pixel del grid fuori dalla penisola iberica e dalle isle
	my.map3<-spplot(my.grid.high,nome.mese.short[my.period],main=my.main,par.settings = standard.theme(color = FALSE),layout=c(1,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout,cex=.5,names.attr=my.names,par.strip.text = list(cex = .9),colorkey=list(space="bottom",width=0.5,height=.8,labels=list(at=my.cuts.in.leyend,labels=my.labels,cex=.6)))		

	# visualizza per ogni WT la sua efficienza mensile (senza composizione):
	upper.limit=100 # limite massimo sopra il quale tutti i dati vengono ridotti a questo numero 
	my.cuts<- seq(1,upper.limit,1) #^0.5 # fa la radice quadrata per diminuire le differenze tra i valori piu' alti e quelli piu' bassi in modo che non ci sia un colore che domina la legenda; occhio che funziona solo se la variabile da rappresentare non e' negativa!!!
	my.labels=c("1%","25%","50%","75%",paste(upper.limit,"%",sep="")) # i numeri che vuoi vedere visualizzati nella legenda, anche se nella mappa si visualizzano in realta' le loro radici
	my.cuts.in.leyend<-c(1,25,50,75,upper.limit) #^0.5 # posizione tacche della legenda dove si visualizzano i my.labels
	my.color=rev(jet.colors7(1000))
	my.names<-nome.mese[my.period]
	my.main<-list(label="Efficiency",cex=1,vjust=1) # vjust sposta il titolo un piu'in basso, vedi ?xy.plot sotto la descrizione di main
	my.var=prec.wt.eff# inserisci qui la variabile da mappare (dev'essere un array del tipo [lat,lon,mese], se e' diverso modica la riga sopra l'spplot)
	# disegna la stessa mappa ma senza sbavature:
	my.grid.high<-grid.high.vuoto;my.var.high<-array(NA,c(dim(my.var)[1]*multiply,dim(my.var)[2]*multiply,dim(my.var)[3],dim(my.var)[4]));for(i in 1:dim(my.var.high)[1]){for(j in 1:dim(my.var.high)[2])my.var.high[i,j,wt,]<-my.var[ceiling(i/multiply),ceiling(j/multiply),wt,]}
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]]<-as.vector(t(rescale.max(my.var.high[,,wt,mese],upper.limit))) #^0.5 # carica i dati nel grid (la radice serve per disegnare la colorkey con colori meglio distribuiti)
	for(mese in 1:12)my.grid.high@data[[nome.mese.short[mese]]][sea.high.pixels]<-NA # elimina i pixel del grid fuori dalla penisola iberica e dalle isle
	my.map4<-spplot(my.grid.high,nome.mese.short[my.period],main=my.main,par.settings = standard.theme(color = FALSE),layout=c(1,4),as.table=T,
		at=my.cuts,col.regions=my.color,sp.layout=my.layout2,cex=.5,names.attr=my.names,par.strip.text = list(cex = .9),colorkey=list(space="bottom",width=0.5,height=.8,labels=list(at=my.cuts.in.leyend,labels=my.labels,cex=.6)))		
		# scales=list(draw = TRUE,cex=.5), # per aggiungere le coordinate geografiche sui bordi
		# strip=FALSE per non disegnare i titoli dei grafici!!!!! strip.left=TRUE per aggiungerla anche a sinistra!!!!!
		
	#jpeg(paste("C:/nicola/precipitaciones/weather_types/Ip02/21) Ip02_WTs_all_indices/",WTs.type[wt],".jpg",sep=""),quality=100)
	png(paste("C:/nicola/precipitaciones/weather_types/Ip02/22) Ip02_WTs_all_indices_as_tiff_high_res/",WTs.type[wt],".tif",sep=""),width=460,height=460)
	textplot(".",cex=1.4,col="white",srt=90,mar=c(0,0,20,23)) # quando si ruota purtroppo si tronca l'ultima parte del testo
	#print(textplot(WTs.type.very.long[wt],cex=1.4,halign="center",valign="top",mar=c(30,0,0,0)),more=T) # il 30 lo sposta verso l'alto per non sovrapporlo ai nomi degli indici
	print(my.map1, position= c(-0.01,0,0.28,1),more=T) # (xmin, ymin, xmax, ymax)
	print(my.map2, position= c(0.23,0,0.52,1),more=T) # (xmin, ymin, xmax, ymax)
	title(WTs.type.very.long2[wt],cex=1.4,srt=0,outer=TRUE,line=-1)
	print(my.map3, position= c(0.471,0,0.76,1),more=T) # (xmin, ymin, xmax, ymax) # pon 0.47 si no quieres crear lineas verticales en la cartografia automatica; pon 0.471 si quieres copiar las imagenes en Paint.NET para subir la resolucion a 660 dpi.
	print(my.map4, position= c(0.711,0,1.00,1),more=T) # (xmin, ymin, xmax, ymax)
	dev.off()
}

# grafico riassuntivo con label intelligenti:
# library(plotrix)
# library(squash)
# par(mfrow=c(4,3));par(oma=c(0,0,0,0));  par(mar=c(2.3,2.5,1,0)) # oma controlla il bordo esterno a tutti i grafici, mar i bordi interni tra grafici
# for(mese in 1:12){
	# x<-1+prec.wt.int.medio[,mese]
	# y<-1+prec.wt.clim.medio[mese,]
	# z<-prec.wt.eff.medio[,mese]
	# my.max<-ceiling(max(prec.wt.int.medio[,mese],prec.wt.clim.medio[mese,]))
	# my.palette<-rev(jet.colors12(100));my.colors<-my.palette[z] # divide la paletta in 100 colori ed estrae a quali colori corrispondono i valori di efficienza, che essendo numeri da 1 a 100 si possono confrontare con i 100 colori della paletta
	# plot(x,y,log="xy",type="n",axes=F,xlim=1+c(0,my.max),ylim=1+c(0,my.max),xlab="",ylab="",mgp=c(2,0,0)) # disegna il grafico vuoto
	# title(xlab="Prec.Intensity (mm/day)",mgp=c(1.3,0,0)) # la prima opzione
	# title(ylab="Prec.Sum (mm)",,mgp=c(1.3,0,0))
	# axis(1, at=1+0:my.max,labels=0:my.max,cex.axis=.8,mgp=c(0,0.5,0))
	# axis(2, at=1+0:my.max,labels=0:my.max,cex.axis=.8,mgp=c(0,0.5,0))
	# segments(1,1,1+my.max,1+my.max,col="gray") # bisettrice
	# segments(1+0:my.max,1,1+0:my.max,1+my.max,col="gray") # linee verticali maglia
	# segments(1,1+0:my.max,1+my.max,1+0:my.max,col="gray") # linee orizzontali maglia
	# points(x,y,cex=1.2,pch=21,bg=my.colors) # cerchietti dei WTs
	# #text((z.labels)^0.5-0.1,(z.labels)^0.5+0.1,labels=z.labels,srt=53)
	# text(my.max*6/10,my.max*6/10,labels="Frequency = 3.3% or 1 dd/mth",srt=42,cex=.9)
	# thigmophobe.labels(x,y,WTs.type,cex=.7,col=WTs.color)
	# title(nome.mese.short[mese],line=-0.1)
# }
# map<-list(breaks=0:100,colors=my.palette)
# hkey(map,title="Prec.Efficiency (%)",skip=25) #,stretch=.3)

# grafico Prec.tot vs Prec.Intensity y Frequency:
scala.log=FALSE
x<-prec.wt.int.medio
y<-prec.wt.sum.norm.medio
my.xmax<-10
my.ymax<-34 #ceiling(max(x,y))
my.wts=c("W","C","NE","SW","NW") #,"N","E")
my.wts.col=c("blue","red","darkgreen","cyan3","darkgoldenrod3") #,"gray","purple")
my.wts=c("W","C","NE","SW","NW","N","E")
my.wts.col=c("blue","red","darkgreen","cyan3","darkgoldenrod3","gray","purple")
l=0;if(scala.log==TRUE)l=1
x<-l+x;y<-l+y

tiff(paste("C:/nicola/precipitaciones/weather_types/Ip02/Figure8.tif",sep=""),res=50)
if(scala.log==TRUE)plot(x,y,log="xy",type="n",axes=F,xlim=1+c(0,my.xmax),ylim=1+c(0,my.ymax),xlab="",ylab="",mgp=c(2,0,0)) # disegna il grafico vuoto
if(scala.log==FALSE)plot(x,y,type="n",axes=F,xlim=c(0,my.xmax),ylim=c(0,my.ymax),xlab="",ylab="",mgp=c(2,0,0)) # disegna il grafico vuoto
#title("Prec.Tot vs. Prec.Intensity",line=-0.1)
title(xlab="Precipitation Intensity (mm/day)",cex.sub=20,mgp=c(2,0,0)) 
title(ylab="Percentage Contribution (%)",,mgp=c(2,0,0))
axis(1, at=l+0:my.xmax,labels=0:my.xmax,cex.axis=.8,mgp=c(0,0.5,0))
axis(2, at=l+0:my.ymax,labels=0:my.ymax,cex.axis=.8,mgp=c(0,0.5,0))
#segments(l+0:my.xmax,l,l+0:my.xmax,l+my.ymax,col="gray") # linee verticali maglia
#segments(l,l+0:my.ymax,l+my.xmax,l+0:my.ymax,col="gray") # linee orizzontali maglia
# segments(l,l,l+my.xmax,l+my.xmax,col="gray") # bisettrice
# if(scala.log==TRUE){text(my.xmax*7/10,my.xmax*7/10,labels="Freq.= 1 dd/mth (3.3%)",srt=38,cex=.9)}else{text(8,8.5,labels="Freq.= 1 dd/mth (3.3%)",srt=14,cex=.9)}
# fr<-0.5;passo=0.2;for(i in seq(0,(my.xmax-l-passo),passo))segments(l+i,l+i*fr,l+i+passo,l+(i+passo)*fr,col="gray") # segmento per Freq=0.5 days/month
# if(scala.log==TRUE){text(l+8,l+4,labels="0.5 dd/m",srt=38,cex=.9)}else{text(9.7,5.5,labels="0.5 dd/m",cex=.9)}
# fr<-2;passo=0.2;for(i in seq(0,my.xmax-0.2,passo))segments(l+i,l+i*fr,l+i+passo,l+(i+passo)*fr,col="gray") 
# if(scala.log==TRUE){text(l+6,l+12,labels="2 dd/m",srt=38,cex=.9)}else{text(10,20,labels="2 dd/m",cex=.9)}
# fr<-4;passo=0.2;for(i in seq(0,8.2,passo))segments(l+i,l+i*fr,l+i+passo,l+(i+passo)*fr,col="gray")
# if(scala.log==TRUE){text(l+4,l+16,labels="4 dd/m",srt=38,cex=.9)}else{text(8.5,34,labels="4 dd/m",cex=.9)}
# fr<-8;passo=0.2;for(i in seq(0,4,passo))segments(l+i,l+i*fr,l+i+passo,l+(i+passo)*fr,col="gray")
# if(scala.log==TRUE){text(l+4,l+16,labels="4 dd/m",srt=38,cex=.9)}else{text(4.5,34,labels="8 dd/m",cex=.9)}
points(x,y,cex=.3,pch=19) # puntini dei WTs
my.wts.num<-match(my.wts,WTs.type);n.wts<-length(my.wts)
for(wt in 1:n.wts){
	x2<-x[my.wts.num[wt],];y2<-y[my.wts.num[wt],]
	points(x2[c(12,1,2)],y2[c(12,1,2)],cex=.7,pch=19,col=my.wts.col[wt]) # winter
	points(x2[c(3,4,5)],y2[c(3,4,5)],cex=.7,pch=17,col=my.wts.col[wt]) # spring
	points(x2[c(6,7,8)],y2[c(6,7,8)],cex=.7,pch=15,col=my.wts.col[wt]) # summer
	points(x2[c(9,10,11)],y2[c(9,10,11)],cex=.5,pch=25,col=my.wts.col[wt],bg=my.wts.col[wt]) # autumn
}
#legend("topright",legend=my.wts,col=my.wts.col,pch=20,horiz=T)
xmin=6;ymin=31;passo=1
text(xmin+2.1,ymin+3.1*passo,paste(my.wts,collapse="   "))
text(xmin-0.6,ymin+1.7*passo,"Winter")
text(xmin-0.6,ymin+0.7*passo,"Spring")
text(xmin-0.6,ymin-0.3*passo,"Summer")
text(xmin-0.6,ymin-1.3*passo,"Autumn")
legend(xmin,ymin+3*passo,legend=rep("",n.wts),col=my.wts.col,pch=19,horiz=T,bty="n")
legend(xmin,ymin+2*passo,legend=rep("",n.wts),col=my.wts.col,pch=17,horiz=T,bty="n")
legend(xmin,ymin+passo,legend=rep("",n.wts),col=my.wts.col,pch=15,horiz=T,bty="n")
legend(xmin,ymin,legend=rep("",n.wts),col=my.wts.col,pch=25,pt.bg=my.wts.col,horiz=T,bty="n")
dev.off()

# fit efficienza vs intensita':
x<-as.vector(prec.wt.int.medio) # as.vector() e'necessario solo per la regressione
y<-as.vector(prec.wt.eff.medio)
plot(x,y,cex=.3,pch=19,xlab="Prec.Intensity (mm/day)",ylab="Prec.Efficiency (%)") #,xaxs="i", yaxs="i") # xaxs="i" fa iniziare gli assi in 0,0
#abline(lm(y~0+x),col="red",lwd=1.5) # regressione con retta
my.lm<-lm(y~x+I(x^2)) # per fare il fit polinomiale
my.lm<-lm(y~x) # per fare il fit lineare
my.x<-seq(0,9.2,0.1)
my.poly=my.lm[[1]][1]+my.lm[[1]][2]*my.x+my.lm[[1]][3]*(my.x^2)
points(my.x,my.poly, type="l", col="blue", lwd=1,cex=.5)
#my.poly<-function(my.x) my.lm[[1]][1]+my.lm[[1]][2]*my.x+my.lm[[1]][3]*(my.x^2)
#curve(my.poly,0,10) # per disegnare una funzione


# grafico intensita' vs efficienza:
my.wts=c("W","C","NE","SW","NW","N","E")
my.wts.col=c("blue","red","darkgreen","purple","darkgoldenrod3","cyan3","gray")
my.wts=c("C.W","C.SW","C.NW","C","W")
my.wts.col=c("blue","red","darkgreen","purple","darkgoldenrod3")

x<-prec.wt.eff.medio
y<-prec.wt.int.medio
plot(x,y,type="n",ylab="Prec.Intensity (mm/day)",xlab="Prec.Efficiency (%)",xaxs="i", yaxs="i",ylim=c(0,9.5),xlim=c(0,75),yaxp=c(0,9,9)) # xaxs="i" fa iniziare gli assi in 0,0
#title("Intensity vs. Efficiency")
points(x,y,cex=.3,pch=19)
my.wts.num<-match(my.wts,WTs.type);n.wts<-length(my.wts)
for(wt in 1:n.wts){
	x2<-x[my.wts.num[wt],];y2<-y[my.wts.num[wt],]
	points(x2[c(12,1,2)],y2[c(12,1,2)],cex=.7,pch=19,col=my.wts.col[wt]) # winter
	points(x2[c(3,4,5)],y2[c(3,4,5)],cex=.7,pch=17,col=my.wts.col[wt]) # spring
	points(x2[c(6,7,8)],y2[c(6,7,8)],cex=.7,pch=15,col=my.wts.col[wt]) # summer
	points(x2[c(9,10,11)],y2[c(9,10,11)],cex=.5,pch=25,col=my.wts.col[wt],bg=my.wts.col[wt]) # autumn
}
#legend("bottomright",legend=my.wts,col=my.wts.col,pch=20)
xmin=15;ymin=8;passo=0.3
text(xmin+9,ymin+3.1*passo,"C.W   C.SW   C.NW   C      W",cex=.7)
text(xmin-6,ymin+1.7*passo,"Winter")
text(xmin-6,ymin+0.7*passo,"Spring")
text(xmin-6,ymin-0.3*passo,"Summer")
text(xmin-6,ymin-1.3*passo,"Autumn")
legend(xmin,ymin+3*passo,legend=rep("",5),col=my.wts.col,pch=19,horiz=T,bty="n")
legend(xmin,ymin+2*passo,legend=rep("",5),col=my.wts.col,pch=17,horiz=T,bty="n")
legend(xmin,ymin+passo,legend=rep("",5),col=my.wts.col,pch=15,horiz=T,bty="n")
legend(xmin,ymin,legend=rep("",5),col=my.wts.col,pch=25,pt.bg=my.wts.col,horiz=T,bty="n")

# fit Prec.Tot vs Area:
my.wts=c("W","C","NE","SW","NW") #,"N","E")
my.wts.col=c("blue","red","darkgreen","cyan3","darkgoldenrod3") #,"cyan3","gray")
x<-area.wt.clim.threshold
y<-prec.wt.sum.norm.medio
plot(x,y,type="n",ylab="Percentage Contribution (%)",xlab="Area of influence (%)",xaxs="i", yaxs="i",ylim=c(-0.05,35),xlim=c(-0.01,1.01),axes=F) # xaxs="i" fa iniziare gli assi in 0,0
axis(1, at=seq(0,1,0.1),labels=seq(0,100,10),cex.axis=.8,mgp=c(0,0.5,0))
axis(2, at=seq(0,35,5),labels=seq(0,35,5),cex.axis=.8,mgp=c(0,0.5,0))
#title("% Contribution vs % Area > 1mm.")
points(x,y,cex=.3,pch=19)
my.wts.num<-match(my.wts,WTs.type);n.wts<-length(my.wts)
for(wt in 1:n.wts){
	x2<-x[my.wts.num[wt],];y2<-y[my.wts.num[wt],]
	points(x2[c(12,1,2)],y2[c(12,1,2)],cex=.7,pch=19,col=my.wts.col[wt]) # winter
	points(x2[c(3,4,5)],y2[c(3,4,5)],cex=.7,pch=17,col=my.wts.col[wt]) # spring
	points(x2[c(6,7,8)],y2[c(6,7,8)],cex=.7,pch=15,col=my.wts.col[wt]) # summer
	points(x2[c(9,10,11)],y2[c(9,10,11)],cex=.5,pch=25,col=my.wts.col[wt],bg=my.wts.col[wt]) # autumn
}
#legend("topleft",legend=my.wts,col=my.wts.col,pch=20)

xmin=0.2;ymin=30;passo=1
text(xmin+0.15,ymin+3.1*passo,paste(my.wts,collapse="   "))
text(xmin-0.06,ymin+1.7*passo,"Winter")
text(xmin-0.06,ymin+0.7*passo,"Spring")
text(xmin-0.06,ymin-0.3*passo,"Summer")
text(xmin-0.06,ymin-1.3*passo,"Autumn")
legend(xmin,ymin+3*passo,legend=rep("",5),col=my.wts.col,pch=19,horiz=T,bty="n")
legend(xmin,ymin+2*passo,legend=rep("",5),col=my.wts.col,pch=17,horiz=T,bty="n")
legend(xmin,ymin+passo,legend=rep("",5),col=my.wts.col,pch=15,horiz=T,bty="n")
legend(xmin,ymin,legend=rep("",5),col=my.wts.col,pch=25,pt.bg=my.wts.col,horiz=T,bty="n")



save.image("C:/nicola/precipitaciones/weather_types/Ip02/Analisi_WTs_Ip02_v16_percentiles.RData")
#draw.ellipse(rep(0,my.max),rep(0,my.max),1:my.max,1:my.max,lty=3) #,border="gray")
#draw.circle(0,0,1,border=NULL,col=NA,lty=1,lwd=1) #symbols(0,0,circle=1,add=T) non vanno bene perche' il cerchio non e' proporzionale all'asse delle y
#text(wt.n.days.mean[,mese],prec.wt.int.medio[,mese],WTs.type,pos=4) # disegna tutti i label a destra dei punti, ma a volte si sovrappongono
#pointLabel(wt.n.days.mean[,mese],prec.wt.int.medio[,mese],WTs.type,cex=.8) # due modi alternativi di automatizzare i label ma non vanno molto bene
#install.packages("directlabels");library(directlabels);direct.label(xyplot(prec.wt.int.medio[,mese]~wt.n.days.mean[,mese],groups=WTs.type))
#plot(prec.wt.sum.norm.medio,area.wt.clim.threshold,cex=.3,pch=19,xlab="Prec.Sum (mm)",ylab="% Area > 1 mm")


library(plotrix)

neutral.city=199;n.neutral.city=18
tomb=188;n.tomb=4
temple=166;n.temple=4
dungeon=155;n.dungeon=10
sorcery=103;n.sorcery=5
mtower=7;n.mtower=7
plain=111;n.plain=120-n.mtower-n.sorcery-n.dungeon-n.temple-n.tomb-n.neutral.city

chaos=904;n.chaos=5
mithril=955;n.mithril=4
silver=911;n.silver=8
gold=922;n.gold=6
mountain=999;n.mountain=55-n.mithril-n.chaos-n.silver-n.gold

tomb2=288;n.tomb2=4
temple2=266;n.temple2=4
lair=255;n.lair=30
nature=202;n.nature=5
forest=222;n.forest=80-n.lair-n.nature-n.temple2-n.tomb2

sea.river=1;n.sea.river=25
sea.ruin=5;n.sea.ruin=16
sea.city=9;n.sea.city=10
sea.sorcery=3;n.sea.sorcery=3
sea.nature=2;n.sea.nature=3
sea.chaos=4;n.sea.chaos=3
sea=0;n.sea=150-n.sea.chaos-n.sea.nature-n.sea.sorcery-n.sea.city-n.sea.ruin-sea.river

lun=15 #27 o 21
alt=15 

n.cas<-alt*lun
#land<-matrix(sample(c(999,0),n.cas,replace=FALSE,prob=c(0.6,0.4)),alt,lun)
land<-matrix(sample(c(rep(plain,n.plain),rep(gold,n.gold),rep(sea.ruin,n.sea.ruin),rep(sorcery,n.sorcery),rep(sea.sorcery,n.sea.sorcery),rep(sea.nature,n.sea.nature),rep(mountain,n.mountain),rep(chaos,n.chaos),rep(mithril,n.mithril),rep(forest,n.forest),
		rep(lair,n.lair),rep(silver,n.silver),rep(neutral.city,n.neutral.city),rep(nature,n.nature),rep(tomb2,n.tomb2),rep(tomb,n.tomb),rep(temple2,n.temple2),
		rep(temple,n.temple),rep(sea.river,n.sea.river),rep(sea.city,n.sea.city),rep(dungeon,n.dungeon),rep(mtower,n.mtower),rep(sea.chaos,n.sea.chaos),rep(sea,n.sea)),n.cas,replace=FALSE),alt,lun) # sample sin replacement (simula la situazione di pescare 375 tessere dal contenitore con 400 tessere
land

color2D.matplot(land)





plain=111;n.plain=93
desert=333;n.desert=45
forest=222;n.forest=60
mountain=7777;n.mountain=54
sea=0;n.sea=126


lun=21 #15,18 o 21
alt=15 

n.cas<-alt*lun
land<-matrix(sample(c(rep(plain,n.plain),rep(mountain,n.mountain),rep(forest,n.forest),rep(desert,n.desert),rep(sea,n.sea)),n.cas,replace=FALSE),alt,lun) # sample sin replacement (simula la situazione di pescare 375 tessere dal contenitore con 400 tessere
land

