Académie de Versailles

Académie de Versailles
Accompagnement académique

IPR Référent : Fabien Serret
Contact : Fabien Serret, fabien.serret@ac-versailles.fr

{"map_options":{"center_lat":"49.03103130580265","center_lng":"2.0926915796948675","zoom":7,"map_type_id":"HYBRID","center_by_nearest":false,"fit_bounds":false,"center_circle_fillcolor":"#8CAEF2","center_circle_strokecolor":"#8CAEF2","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","draggable":true,"scroll_wheel":"true","gesture":"auto","marker_default_icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/11-generic.png","infowindow_setting":"<div class=\"fc-main\">\n<div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}<\/span><\/div>\n<div class=\"fc-item-featured_image\">{marker_image} <\/div>\n<p>{marker_message}<\/p>\n<address><b>Address : <\/b>{marker_address}<\/address>\n<\/div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                {post_excerpt}\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div>{post_featured_image}<div id=\"contenu_article\">{post_content}<\/div><\/div>","infowindow_skin":{"name":"default","type":"infowindow","sourcecode":"<div class=\"fc-main\"><div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}<\/span><\/div> <div class=\"fc-item-featured_image\">{marker_image} <\/div>{marker_message}<address><b>Address : <\/b>{marker_address}<\/address><\/div>"},"infowindow_post_skin":{"name":"udine","type":"post","sourcecode":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                {post_excerpt}\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div>{post_featured_image}<div id=\"contenu_article\">{post_content}<\/div><\/div>"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"default_infowindow_open":false,"infowindow_open_event":"mouseover","infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":false,"full_screen_control":false,"search_control":true,"zoom_control":true,"map_type_control":false,"street_view_control":false,"locateme_control":false,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":"10","url_filters":false,"doubleclickzoom":false,"current_post_only":false,"bound_map_after_filter":true,"display_reset_button":true,"map_reset_button_text":"R\u00e9initialiser","height":"600"},"places":[{"source":"post","title":"Berge de Pontoise","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Pontoise<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Pontoise \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Pontoise\" width=\"199\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Pal_22_23_V_16_Photo_Site-199x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Pontoise<\/h2>\n<p>Latitude : 49.0322N | Longitude : 2.0596E<br \/>Commune : Pontoise<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul><\/div><\/div>","content":"Pontoise \u2022 2022-2023","address":"","location":{"lat":"49.03103130580265","lng":"2.0926915796948675","redirect_custom_link":"","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-pontoise\/","zoom":7,"extra_fields":{"post_excerpt":"Pontoise \u2022 2022-2023","post_content":"<h2 class=\"site\">Berge de Pontoise<\/h2>\n<p>Latitude : 49.0322N | Longitude : 2.0596E<br \/>Commune : Pontoise<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>","post_title":"Berge de Pontoise","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-pontoise\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Pontoise\" width=\"199\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Pal_22_23_V_16_Photo_Site-199x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"49.03103130580265","%_wpgmp_metabox_longitude%":"2.0926915796948675","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_22-23_V_16","%_thumbnail_id%":"11566","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":11568,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge L\u00e9onard de Vinci","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge L\u00e9onard de Vinci<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge L\u00e9onard de Vinci\" width=\"300\" height=\"199\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Pal_22_23_V_16_Photo_VracMacro-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge L\u00e9onard de Vinci<\/h2>\n<p>Commune\u00a0: Eragny-sur-oise<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>7 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Pontoise\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","location":{"lat":"49.02241999679238","lng":"2.110589254431442","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-leonard-de-vinci-2\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge L\u00e9onard de Vinci<\/h2>\n<p>Commune\u00a0: Eragny-sur-oise<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>7 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Pontoise\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge L\u00e9onard de Vinci","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-leonard-de-vinci-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge L\u00e9onard de Vinci\" width=\"300\" height=\"199\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Pal_22_23_V_16_Photo_VracMacro-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"49.02241999679238","%_wpgmp_metabox_longitude%":"2.110589254431442","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_22-23_V_16#","%_thumbnail_id%":"11565","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":11569,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Triel-sur-Seine","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Triel-sur-Seine<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Triel-sur-Seine \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Triel-sur-Seine\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-V-12-1_photo_site-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Triel-sur-Seine<\/h2>\n<p>Latitude : 48.984968N | Longitude : 1.9931112046E<br \/>Commune : Triel-sur-Seine<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Triel-sur-Seine \u2022 2022-2023","location":{"lat":"48.9849680585564","lng":"1.9931112046185007","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-triel-sur-seine\/","zoom":7,"extra_fields":{"post_excerpt":"Triel-sur-Seine \u2022 2022-2023","post_content":"<h2 class=\"site\">Berge de Triel-sur-Seine<\/h2>\n<p>Latitude : 48.984968N | Longitude : 1.9931112046E<br \/>Commune : Triel-sur-Seine<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Berge de Triel-sur-Seine","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-triel-sur-seine\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Triel-sur-Seine\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-V-12-1_photo_site-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.9849680585564","%_wpgmp_metabox_longitude%":"1.9931112046185007","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_22-23_V_12","%_wp_page_template%":"default","%_thumbnail_id%":"11552","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":8865,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Les Ch\u00e2telaines","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Les Ch\u00e2telaines<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Les Ch\u00e2telaines\" width=\"300\" height=\"193\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-V-12-6_Photo_CategMacro-300x193.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge De La Rivi\u00e8re<\/h2>\n<p>Commune\u00a0: Triel-sur-Seine<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>160 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Triel-sur-Seine\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2022-2023","location":{"lat":"48.977015149818435","lng":"2.0165924403016717","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-les-chatelaines\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge De La Rivi\u00e8re<\/h2>\n<p>Commune\u00a0: Triel-sur-Seine<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>160 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Triel-sur-Seine\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Les Ch\u00e2telaines","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-les-chatelaines\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Les Ch\u00e2telaines\" width=\"300\" height=\"193\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-V-12-6_Photo_CategMacro-300x193.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.977015149818435","%_wpgmp_metabox_longitude%":"2.0165924403016717","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_22-23_V_12#","%_wp_page_template%":"default","%_thumbnail_id%":"11553","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":8866,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Parc de Cergy","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Parc de Cergy<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Cergy \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Parc de Cergy\" width=\"226\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-V-13-1_Photo_Site-226x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Parc de Cergy<\/h2>\n<p>Latitude : 49.0322N | Longitude : 2.0596E<br \/>Commune : Cergy<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-13FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-13FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Cergy \u2022 2022-2023","location":{"lat":"49.0322","lng":"2.0596","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/parc-de-cergy\/","zoom":7,"extra_fields":{"post_excerpt":"Cergy \u2022 2022-2023","post_content":"<h2 class=\"site\">Parc de Cergy<\/h2>\n<p>Latitude : 49.0322N | Longitude : 2.0596E<br \/>Commune : Cergy<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-13FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-13FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Parc de Cergy","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/parc-de-cergy\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Parc de Cergy\" width=\"226\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-V-13-1_Photo_Site-226x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"49.0322","%_wpgmp_metabox_longitude%":"2.0596","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_22-23_V_13","%_wp_page_template%":"default","%_thumbnail_id%":"11554","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":8867,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Polyvalent De L&rsquo;Hautil","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Polyvalent De L&rsquo;Hautil<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e Polyvalent De L&rsquo;Hautil\" width=\"300\" height=\"226\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-V-13-6_Photo_CategMacro-300x226.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Polyvalent De L'Hautil<\/h2>\n<p>Commune\u00a0: Jouy Le Moutier<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Parc de Cergy\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-13FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-13FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","location":{"lat":"49.01033485066856","lng":"2.0253127979753165","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-polyvalent-de-lhautil\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","post_content":"<h2>Lyc\u00e9e Polyvalent De L'Hautil<\/h2>\n<p>Commune\u00a0: Jouy Le Moutier<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Parc de Cergy\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-13FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-13FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Lyc\u00e9e Polyvalent De L&rsquo;Hautil","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-polyvalent-de-lhautil\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e Polyvalent De L&rsquo;Hautil\" width=\"300\" height=\"226\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-V-13-6_Photo_CategMacro-300x226.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"49.01033485066856","%_wpgmp_metabox_longitude%":"2.0253127979753165","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_22-23_V_13#","%_wp_page_template%":"default","%_thumbnail_id%":"11555","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":8868,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Chemin de Halage","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Chemin de Halage<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coudray-Montceaux \u2022 2020-2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chemin de Halage\" width=\"300\" height=\"125\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V_6_Photo_Site-300x125.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Chemin de Halage<\/h2>\n<p>Latitude : 48.569679\u00b0N | Longitude : 2.51081\u00b0E<br \/>Commune : Le Coudray-Montceaux\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coudray-Montceaux \u2022 2020-2021-2022-2023","location":{"lat":"48.569679","lng":"2.51081","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/chemin-de-halage-3\/","zoom":7,"extra_fields":{"post_excerpt":"Coudray-Montceaux \u2022 2020-2021-2022-2023","post_content":"<h2 class=\"site\">Chemin de Halage<\/h2>\n<p>Latitude : 48.569679\u00b0N | Longitude : 2.51081\u00b0E<br \/>Commune : Le Coudray-Montceaux\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Chemin de Halage","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/chemin-de-halage-3\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chemin de Halage\" width=\"300\" height=\"125\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V_6_Photo_Site-300x125.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.569679","%_wpgmp_metabox_longitude%":"2.51081","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_6","%_wp_page_template%":"default","%_thumbnail_id%":"11558","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7321,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Jean-Baptiste Corot","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Jean-Baptiste Corot<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2020-2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e Jean-Baptiste Corot\" width=\"120\" height=\"160\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V_6_Photo_VracMacro-rotated.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Jean-Baptiste Corot<\/h2>\n<p>Commune : Savigny-sur-Orge<br \/>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>10 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Halage\" de la commune du Coudray-Montceaux.\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Halage\" de la commune du Coudray-Montceaux.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Halage\" de la commune du Coudray-Montceaux.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2020-2021-2022-2023","location":{"lat":"48.674599125845965","lng":"2.3542472541368813","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-jean-baptiste-corot-2\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2020-2021-2022-2023","post_content":"<h2>Lyc\u00e9e Jean-Baptiste Corot<\/h2>\n<p>Commune : Savigny-sur-Orge<br \/>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>10 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Halage\" de la commune du Coudray-Montceaux.\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Halage\" de la commune du Coudray-Montceaux.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Halage\" de la commune du Coudray-Montceaux.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Jean-Baptiste Corot","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-jean-baptiste-corot-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e Jean-Baptiste Corot\" width=\"120\" height=\"160\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V_6_Photo_VracMacro-rotated.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.674599125845965","%_wpgmp_metabox_longitude%":"2.3542472541368813","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_6#","%_wp_page_template%":"default","%_thumbnail_id%":"11559","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7322,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Quai Charles de Gaulle","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Quai Charles de Gaulle<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Carri\u00e8res-sur-Seine \u2022 2020-2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Quai Charles de Gaulle\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Photo_Site-avec-eleves_PAL_22_23_V_7-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Quai Charles de Gaulle<\/h2>\n<p>Latitude : 48.9054264\u00b0N | Longitude : 2.1807760\u00b0E<br \/>Commune : Carri\u00e8res-sur-Seine\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Carri\u00e8res-sur-Seine \u2022 2020-2021-2022-2023","location":{"lat":"48.905426431126074","lng":"2.1807760000229726","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/quai-charles-de-gaulle-2\/","zoom":7,"extra_fields":{"post_excerpt":"Carri\u00e8res-sur-Seine \u2022 2020-2021-2022-2023","post_content":"<h2 class=\"site\">Quai Charles de Gaulle<\/h2>\n<p>Latitude : 48.9054264\u00b0N | Longitude : 2.1807760\u00b0E<br \/>Commune : Carri\u00e8res-sur-Seine\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Quai Charles de Gaulle","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/quai-charles-de-gaulle-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Quai Charles de Gaulle\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Photo_Site-avec-eleves_PAL_22_23_V_7-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.905426431126074","%_wpgmp_metabox_longitude%":"2.1807760000229726","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_7","%_wp_page_template%":"default","%_thumbnail_id%":"11556","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7323,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Lakanal","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Lakanal<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2020-2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Lakanal\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Photo_Site-et-pollution_PAL_22_23_V_7-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Lakanal<\/h2>\n<p>Commune : Colombes<br \/>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Quai Charles de Gaulle\" de la commune du Carri\u00e8res-sur-Seine.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Quai Charles de Gaulle\" de la commune du Carri\u00e8res-sur-Seine. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Quai Charles de Gaulle\" de la commune du Carri\u00e8res-sur-Seine.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2020-2021-2022-2023","location":{"lat":"48.92360891190266","lng":"2.2518218020146783","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-lakanal-2\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2020-2021-2022-2023","post_content":"<h2>Coll\u00e8ge Lakanal<\/h2>\n<p>Commune : Colombes<br \/>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Quai Charles de Gaulle\" de la commune du Carri\u00e8res-sur-Seine.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Quai Charles de Gaulle\" de la commune du Carri\u00e8res-sur-Seine. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Quai Charles de Gaulle\" de la commune du Carri\u00e8res-sur-Seine.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Lakanal","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-lakanal-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Lakanal\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Photo_Site-et-pollution_PAL_22_23_V_7-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.92360891190266","%_wpgmp_metabox_longitude%":"2.2518218020146783","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_7#","%_wp_page_template%":"default","%_thumbnail_id%":"11557","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7324,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Albert Thierry","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Albert Thierry<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me \u2022 2019-2020-2021\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Albert Thierry\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Albert Thierry<\/h2>\n<p>Commune : Limay<br \/>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de loisirs des boucles de Seine\" de la commune de Moisson.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2019-2020-2021","location":{"lat":"48.997653722026435","lng":"1.7481992290096064","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-albert-thierry-2\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2019-2020-2021","post_content":"<h2>Coll\u00e8ge Albert Thierry<\/h2>\n<p>Commune : Limay<br \/>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de loisirs des boucles de Seine\" de la commune de Moisson.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Albert Thierry","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-albert-thierry-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Albert Thierry\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.997653722026435","%_wpgmp_metabox_longitude%":"1.7481992290096064","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_19-20_V_8#","%_wp_page_template%":"default","%_thumbnail_id%":"1749","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020, 2020-2021, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7316,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020","2020-2021","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Nanterre","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Nanterre<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Nanterre \u2022 2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Nanterre\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V_9-1_Photo_site2-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Nanterre<\/h2>\n<p>Latitude : 48.91339627\u00b0N | Longitude : 2.2109841\u00b0E<br \/>Commune : Nanterre<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V-9_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V-9_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Nanterre \u2022 2021-2022-2023","location":{"lat":"48.9133962722302","lng":"2.2109841359563775","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-nanterre-2\/","zoom":7,"extra_fields":{"post_excerpt":"Nanterre \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Berge de Nanterre<\/h2>\n<p>Latitude : 48.91339627\u00b0N | Longitude : 2.2109841\u00b0E<br \/>Commune : Nanterre<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V-9_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V-9_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge de Nanterre","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-nanterre-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Nanterre\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V_9-1_Photo_site2-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.9133962722302","%_wpgmp_metabox_longitude%":"2.2109841359563775","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_9","%_wp_page_template%":"default","%_thumbnail_id%":"11546","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7327,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Fran\u00e7ois Truffaut","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Fran\u00e7ois Truffaut<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \u2022 2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Fran\u00e7ois Truffaut\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V_9-5_Photo_VracMacro-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Fran\u00e7ois Truffaut<\/h2>\n<p>Commune\u00a0: Asni\u00e8res Sur Seine<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>60 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Nanterre\" de la commune de Nanterre.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V-9_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V-9_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>40 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Nanterre\" de la commune de Nanterre.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022-2023","location":{"lat":"48.9107940812606","lng":"2.283122457724256","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-francois-truffaut-2\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022-2023","post_content":"<h2>Coll\u00e8ge Fran\u00e7ois Truffaut<\/h2>\n<p>Commune\u00a0: Asni\u00e8res Sur Seine<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>60 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Nanterre\" de la commune de Nanterre.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V-9_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_V-9_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>40 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Nanterre\" de la commune de Nanterre.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_V_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Fran\u00e7ois Truffaut","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-francois-truffaut-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Fran\u00e7ois Truffaut\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V_9-5_Photo_VracMacro-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.9107940812606","%_wpgmp_metabox_longitude%":"2.283122457724256","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_9#","%_wp_page_template%":"default","%_thumbnail_id%":"11547","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7328,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Viry-Chatillon","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Viry-Chatillon<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Viry-Chatillon \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Viry-Chatillon<\/h2>\n<p>Latitude : 48.6774894761\u00b0N | Longitude : 2.38768868\u00b0E<br \/>Commune : Viry-Chatillon<\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Viry-Chatillon \u2022 2021-2022","location":{"lat":"48.677489476195134","lng":"2.38768868766007","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-viry-chatillon-2\/","zoom":7,"extra_fields":{"post_excerpt":"Viry-Chatillon \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Viry-Chatillon<\/h2>\n<p>Latitude : 48.6774894761\u00b0N | Longitude : 2.38768868\u00b0E<br \/>Commune : Viry-Chatillon<\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Berge de Viry-Chatillon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-viry-chatillon-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.677489476195134","%_wpgmp_metabox_longitude%":"2.38768868766007","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_10","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7329,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Ferdinand Buisson","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Ferdinand Buisson<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Ferdinand Buisson<\/h2>\n<p>Commune\u00a0: Juvisy-sur-orge<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>18 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Viry-Chatillon\" de la commune de Viry-Chatillon. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2021-2022","location":{"lat":"48.6903032342393","lng":"2.378973363814174","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-ferdinand-buisson-3\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Ferdinand Buisson<\/h2>\n<p>Commune\u00a0: Juvisy-sur-orge<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>18 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Viry-Chatillon\" de la commune de Viry-Chatillon. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Ferdinand Buisson","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-ferdinand-buisson-3\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.6903032342393","%_wpgmp_metabox_longitude%":"2.378973363814174","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_10#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7330,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Guyancourt","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Guyancourt<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Guyancourt \u2022 2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Guyancourt\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V-2-1_Photo_Site-300x225.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Guyancourt<\/h2>\n<p>Latitude : 48.96887\u00b0N | Longitude : 1.686656847\u00b0E<br \/>Commune : Guyancourt<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Guyancourt \u2022 2021-2022-2023","location":{"lat":"48.96887968874861","lng":"1.6866568474675154","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-guyancourt-2\/","zoom":7,"extra_fields":{"post_excerpt":"Guyancourt \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Berge de Guyancourt<\/h2>\n<p>Latitude : 48.96887\u00b0N | Longitude : 1.686656847\u00b0E<br \/>Commune : Guyancourt<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge de Guyancourt","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-guyancourt-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Guyancourt\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V-2-1_Photo_Site-300x225.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.96887968874861","%_wpgmp_metabox_longitude%":"1.6866568474675154","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_2","%_wp_page_template%":"default","%_thumbnail_id%":"11548","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7325,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e St Thomas de Villeneuve","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e St Thomas de Villeneuve<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \u2022 2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e St Thomas de Villeneuve\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V-2-5_PhotoVracMacro2-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e St Thomas de Villeneuve<\/h2>\n<p>Commune\u00a0: Chaville<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Guyancourt\" de la commune de Guyancourt.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Guyancourt\" de la commune de Guyancourt. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2021-2022-2023","location":{"lat":"48.80813015085544","lng":"2.1877100786210866","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-st-thomas-de-villeneuve-2\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2021-2022-2023","post_content":"<h2>Lyc\u00e9e St Thomas de Villeneuve<\/h2>\n<p>Commune\u00a0: Chaville<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Guyancourt\" de la commune de Guyancourt.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Guyancourt\" de la commune de Guyancourt. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e St Thomas de Villeneuve","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-st-thomas-de-villeneuve-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e St Thomas de Villeneuve\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V-2-5_PhotoVracMacro2-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.80813015085544","%_wpgmp_metabox_longitude%":"2.1877100786210866","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_2#","%_wp_page_template%":"default","%_thumbnail_id%":"11549","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7326,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Ile de loisirs des boucles de Seine","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Ile de loisirs des boucles de Seine<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Moisson \u2022 2020-2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ile de loisirs des boucles de Seine\" width=\"224\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V-3-1_Photo_Site-224x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Ile de loisirs des boucles de Seine<\/h2>\n<p>Latitude : 49.060461\u00b0N | Longitude : 1.680672\u00b0E<br \/>Commune : Moisson\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Moisson \u2022 2020-2021-2022-2023","location":{"lat":"49.060461","lng":"1.680672","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-de-loisirs-des-boucles-de-seine-2\/","zoom":7,"extra_fields":{"post_excerpt":"Moisson \u2022 2020-2021-2022-2023","post_content":"<h2 class=\"site\">Ile de loisirs des boucles de Seine<\/h2>\n<p>Latitude : 49.060461\u00b0N | Longitude : 1.680672\u00b0E<br \/>Commune : Moisson\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Ile de loisirs des boucles de Seine","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-de-loisirs-des-boucles-de-seine-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ile de loisirs des boucles de Seine\" width=\"224\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V-3-1_Photo_Site-224x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"49.060461","%_wpgmp_metabox_longitude%":"1.680672","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_3","%_wp_page_template%":"default","%_thumbnail_id%":"11550","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7313,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Nicolas Flamel","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Nicolas Flamel<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Nicolas Flamel\" width=\"224\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V-3-1_Photo_Site-224x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Nicolas Flamel<\/h2>\n<p>Commune\u00a0: Pontoise<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de loisirs des boucles de Seine\" de la commune de Moisson.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h6>Valorisation<\/h6>\n<p>Un article : http:\/\/www.clg-flamel-pontoise.ac-versailles.fr\/spip.php?article1042 <\/p>\n<p>Une vid\u00e9o : https:\/\/tube-action-educative.apps.education.fr\/w\/hkyDYYsaDnCSbjq9nfGGnC<\/p>\n<p>Un podcast : http:\/\/www.alternativefm.fr\/selection-podcasts\/<\/p><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","location":{"lat":"49.05813218177882","lng":"2.0849321998305745","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-nicolas-flamel\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Nicolas Flamel<\/h2>\n<p>Commune\u00a0: Pontoise<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de loisirs des boucles de Seine\" de la commune de Moisson.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-V-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h6>Valorisation<\/h6>\n<p>Un article : http:\/\/www.clg-flamel-pontoise.ac-versailles.fr\/spip.php?article1042 <\/p>\n<p>Une vid\u00e9o : https:\/\/tube-action-educative.apps.education.fr\/w\/hkyDYYsaDnCSbjq9nfGGnC<\/p>\n<p>Un podcast : http:\/\/www.alternativefm.fr\/selection-podcasts\/<\/p>","post_title":"Coll\u00e8ge Nicolas Flamel","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-nicolas-flamel\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Nicolas Flamel\" width=\"224\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_V-3-1_Photo_Site-224x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"49.05813218177882","%_wpgmp_metabox_longitude%":"2.0849321998305745","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_22-23_V_3#","%_wp_page_template%":"default","%_thumbnail_id%":"11550","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":8850,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Ren\u00e9 Cassin","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Ren\u00e9 Cassin<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \u2022 2020-2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Ren\u00e9 Cassin<\/h2>\n<p>Commune : Arpajon<br \/>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>20 \u00e9l\u00e8ves de lyc\u00e9e et BTS<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Sully\" de la commune de Sully-sur-Loire.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Or-6_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Or-6_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de lyc\u00e9e et BTS<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Sully\" de la commune de Sully-sur-Loire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de l'ile aux Moines\" de la commune de Marolles sur Seine.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2020-2021-2022-2023","location":{"lat":"48.59485247763662","lng":"2.240258944723033","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-rene-cassin-2\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2020-2021-2022-2023","post_content":"<h2>Lyc\u00e9e Ren\u00e9 Cassin<\/h2>\n<p>Commune : Arpajon<br \/>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>20 \u00e9l\u00e8ves de lyc\u00e9e et BTS<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Sully\" de la commune de Sully-sur-Loire.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Or-6_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Or-6_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de lyc\u00e9e et BTS<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Sully\" de la commune de Sully-sur-Loire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de l'ile aux Moines\" de la commune de Marolles sur Seine.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Ren\u00e9 Cassin","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-rene-cassin-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_old_slug%":"lycee-rene-cassin-4","%_wpgmp_metabox_latitude%":"48.59485247763662","%_wpgmp_metabox_longitude%":"2.240258944723033","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_22-23_Or_6#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":8845,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Rosa Luxemburg","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Rosa Luxemburg<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Rosa Luxemburg<\/h2>\n<p>Commune\u00a0: Lisses<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Asce Voile Espar\" de la commune de Corbeil Essonnes. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"48.60209449998379","lng":"2.42458442517663","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-rosa-luxemburg-2\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Rosa Luxemburg<\/h2>\n<p>Commune\u00a0: Lisses<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Asce Voile Espar\" de la commune de Corbeil Essonnes. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Rosa Luxemburg","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-rosa-luxemburg-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.60209449998379","%_wpgmp_metabox_longitude%":"2.42458442517663","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_11#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7332,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Buc","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Buc<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Buc \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Buc\" width=\"300\" height=\"171\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5site-300x171.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Buc<\/h2>\n<p>Latitude : 48.7749\u00b0N | Longitude : 2.1289\u00b0E<br \/>Commune : Buc\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Buc \u2022 2020-2021-2022","location":{"lat":"48.7749","lng":"2.1289","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-buc-2\/","zoom":7,"extra_fields":{"post_excerpt":"Buc \u2022 2020-2021-2022","post_content":"<h2 class=\"site\">Berge de Buc<\/h2>\n<p>Latitude : 48.7749\u00b0N | Longitude : 2.1289\u00b0E<br \/>Commune : Buc\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge de Buc","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-buc-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Buc\" width=\"300\" height=\"171\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5site-300x171.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.7749","%_wpgmp_metabox_longitude%":"2.1289","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_5","%_wp_page_template%":"default","%_thumbnail_id%":"4351","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7319,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Martin Luther King","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Martin Luther King<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me\/4\u00e8me \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Martin Luther King<\/h2>\n<p>Commune : Buc<br \/>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Buc\" de la commune de Buc. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me\/4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Buc\" de la commune de Buc.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me\/4\u00e8me \u2022 2020-2021-2022","location":{"lat":"48.77005978962952","lng":"2.1212009694822163","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-martin-luther-king-2\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me\/4\u00e8me \u2022 2020-2021-2022","post_content":"<h2>Coll\u00e8ge Martin Luther King<\/h2>\n<p>Commune : Buc<br \/>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Buc\" de la commune de Buc. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me\/4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Buc\" de la commune de Buc.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Martin Luther King","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-martin-luther-king-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.77005978962952","%_wpgmp_metabox_longitude%":"2.1212009694822163","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_5#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7320,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Asce Voile Espar","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Asce Voile Espar<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Corbeil Essonnes \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Asce Voile Espar<\/h2>\n<p>Latitude : 48.60278007\u00b0N | Longitude : 2.489905193\u00b0E<br \/>Commune : Corbeil Essonnes<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Corbeil Essonnes \u2022 2021-2022","location":{"lat":"48.60278007534101","lng":"2.4899051935436662","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/asce-voile-espar-2\/","zoom":7,"extra_fields":{"post_excerpt":"Corbeil Essonnes \u2022 2021-2022","post_content":"<h2 class=\"site\">Asce Voile Espar<\/h2>\n<p>Latitude : 48.60278007\u00b0N | Longitude : 2.489905193\u00b0E<br \/>Commune : Corbeil Essonnes<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Asce Voile Espar","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/asce-voile-espar-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.60278007534101","%_wpgmp_metabox_longitude%":"2.4899051935436662","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_11","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7331,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de l&rsquo;ile aux Moines","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Plage de l&rsquo;ile aux Moines<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Marolles sur Seine \u2022 2020-2021\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de l&rsquo;ile aux Moines\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1-Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de l'ile aux Moines<\/h2>\n<p>Latitude : 48.391883\u00b0N | Longitude : 3.049026\u00b0E<br \/>Commune : Marolles sur Seine\/p>\n\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Marolles sur Seine \u2022 2020-2021","location":{"lat":"48.391883","lng":"3.049026","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-lile-aux-moines\/","zoom":7,"extra_fields":{"post_excerpt":"Marolles sur Seine \u2022 2020-2021","post_content":"<h2 class=\"site\">Plage de l'ile aux Moines<\/h2>\n<p>Latitude : 48.391883\u00b0N | Longitude : 3.049026\u00b0E<br \/>Commune : Marolles sur Seine\/p>\n\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de l&rsquo;ile aux Moines","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-lile-aux-moines\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de l&rsquo;ile aux Moines\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1-Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_old_slug%":"plage-de-lile-aux-moines-3","%_wpgmp_metabox_latitude%":"48.391883","%_wpgmp_metabox_longitude%":"3.049026","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_1","%_wp_page_template%":"default","%_thumbnail_id%":"4349","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7317,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Georges","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Georges<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Georges<\/h2>\n\n<p>Commune\u00a0: Magnanville<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>28 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de loisirs des boucles de Seine\" de la commune de Moisson. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022","location":{"lat":"48.96887968874861","lng":"1.6866568474675154","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-georges-2\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Georges<\/h2>\n\n<p>Commune\u00a0: Magnanville<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>28 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de loisirs des boucles de Seine\" de la commune de Moisson. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Georges","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-georges-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.96887968874861","%_wpgmp_metabox_longitude%":"1.6866568474675154","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_3#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7314,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e St Thomas de Villeneuve","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e St Thomas de Villeneuve<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e St Thomas de Villeneuve<\/h2>\n\n<p>Commune\u00a0: Chaville<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Guyancourt\" de la commune de Guyancourt. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2021-2022","location":{"lat":"48.80813015085544","lng":"2.1877100786210866","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-st-thomas-de-villeneuve\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2021-2022","post_content":"<h2>Lyc\u00e9e St Thomas de Villeneuve<\/h2>\n\n<p>Commune\u00a0: Chaville<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Guyancourt\" de la commune de Guyancourt. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Lyc\u00e9e St Thomas de Villeneuve","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-st-thomas-de-villeneuve\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.80813015085544","%_wpgmp_metabox_longitude%":"2.1877100786210866","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_2#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4787,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Viry-Chatillon","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Viry-Chatillon<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Viry-Chatillon \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Viry-Chatillon<\/h2>\n<p>Latitude : 48.6774894761\u00b0N | Longitude : 2.38768868\u00b0E<br \/>Commune : Viry-Chatillon<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"Viry-Chatillon \u2022 2021-2022","location":{"lat":"48.677489476195134","lng":"2.38768868766007","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-viry-chatillon\/","zoom":7,"extra_fields":{"post_excerpt":"Viry-Chatillon \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Viry-Chatillon<\/h2>\n<p>Latitude : 48.6774894761\u00b0N | Longitude : 2.38768868\u00b0E<br \/>Commune : Viry-Chatillon<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Berge de Viry-Chatillon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-viry-chatillon\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.677489476195134","%_wpgmp_metabox_longitude%":"2.38768868766007","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_10","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4792,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Ferdinand Buisson","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Ferdinand Buisson<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Ferdinand Buisson<\/h2>\n\n<p>Commune\u00a0: Juvisy-sur-orge<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>18 \u00e9l\u00e8ves de Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Viry-Chatillon\" de la commune de Viry-Chatillon. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2021-2022","location":{"lat":"48.6903032342393","lng":"2.378973363814174","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-ferdinand-buisson-2\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Ferdinand Buisson<\/h2>\n\n<p>Commune\u00a0: Juvisy-sur-orge<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>18 \u00e9l\u00e8ves de Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Viry-Chatillon\" de la commune de Viry-Chatillon. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_10D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Coll\u00e8ge Ferdinand Buisson","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-ferdinand-buisson-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.6903032342393","%_wpgmp_metabox_longitude%":"2.378973363814174","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_10#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4793,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Asce Voile Espar","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Asce Voile Espar<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Corbeil Essonnes \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Asce Voile Espar<\/h2>\n<p>Latitude : 48.60278007\u00b0N | Longitude : 2.489905193\u00b0E<br \/>Commune : Corbeil Essonnes<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"Corbeil Essonnes \u2022 2021-2022","location":{"lat":"48.60278007534101","lng":"2.4899051935436662","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/asce-voile-espar\/","zoom":7,"extra_fields":{"post_excerpt":"Corbeil Essonnes \u2022 2021-2022","post_content":"<h2 class=\"site\">Asce Voile Espar<\/h2>\n<p>Latitude : 48.60278007\u00b0N | Longitude : 2.489905193\u00b0E<br \/>Commune : Corbeil Essonnes<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Asce Voile Espar","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/asce-voile-espar\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.60278007534101","%_wpgmp_metabox_longitude%":"2.4899051935436662","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_11","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4794,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Rosa Luxemburg","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Rosa Luxemburg<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Rosa Luxemburg<\/h2>\n\n<p>Commune\u00a0: Lisses<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Asce Voile Espar\" de la commune de Corbeil Essonnes. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"48.60209449998379","lng":"2.42458442517663","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-rosa-luxemburg\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Rosa Luxemburg<\/h2>\n\n<p>Commune\u00a0: Lisses<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Asce Voile Espar\" de la commune de Corbeil Essonnes. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V11D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Coll\u00e8ge Rosa Luxemburg","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-rosa-luxemburg\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.60209449998379","%_wpgmp_metabox_longitude%":"2.42458442517663","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_11#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4795,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Ile de loisirs des boucles de Seine","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Ile de loisirs des boucles de Seine<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Moisson \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ile de loisirs des boucles de Seine\" width=\"226\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3_Site-226x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Ile de loisirs des boucles de Seine<\/h2>\n<p>Latitude : 49.060461\u00b0N | Longitude : 1.680672\u00b0E<br \/>Commune : Moisson\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"Moisson \u2022 2020-2021-2022","location":{"lat":"49.060461","lng":"1.680672","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-de-loisirs-des-boucles-de-seine\/","zoom":7,"extra_fields":{"post_excerpt":"Moisson \u2022 2020-2021-2022","post_content":"<h2 class=\"site\">Ile de loisirs des boucles de Seine<\/h2>\n<p>Latitude : 49.060461\u00b0N | Longitude : 1.680672\u00b0E<br \/>Commune : Moisson\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Ile de loisirs des boucles de Seine","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-de-loisirs-des-boucles-de-seine\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ile de loisirs des boucles de Seine\" width=\"226\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3_Site-226x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"49.060461","%_wpgmp_metabox_longitude%":"1.680672","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_3","%_wp_page_template%":"default","%_thumbnail_id%":"4350","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4355,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Georges","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Georges<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Georges<\/h2>\n\n<p>Commune\u00a0: Magnanville<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>28 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de loisirs des boucles de Seine\" de la commune de Moisson. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022","location":{"lat":"48.96887968874861","lng":"1.6866568474675154","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-georges\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Georges<\/h2>\n\n<p>Commune\u00a0: Magnanville<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>28 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de loisirs des boucles de Seine\" de la commune de Moisson. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_3D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Coll\u00e8ge Georges","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-georges\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.96887968874861","%_wpgmp_metabox_longitude%":"1.6866568474675154","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_3#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4778,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Buc","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Buc<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Buc \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Buc\" width=\"300\" height=\"171\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5site-300x171.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Buc<\/h2>\n<p>Latitude : 48.7749\u00b0N | Longitude : 2.1289\u00b0E<br \/>Commune : Buc\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"Buc \u2022 2020-2021-2022","location":{"lat":"48.7749","lng":"2.1289","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-buc\/","zoom":7,"extra_fields":{"post_excerpt":"Buc \u2022 2020-2021-2022","post_content":"<h2 class=\"site\">Berge de Buc<\/h2>\n<p>Latitude : 48.7749\u00b0N | Longitude : 2.1289\u00b0E<br \/>Commune : Buc\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Berge de Buc","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-buc\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Buc\" width=\"300\" height=\"171\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5site-300x171.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.7749","%_wpgmp_metabox_longitude%":"2.1289","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_5","%_wp_page_template%":"default","%_thumbnail_id%":"4351","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4360,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Martin Luther King","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Martin Luther King<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me\/4\u00e8me \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Martin Luther King<\/h2>\n<p>Commune : Buc<br \/>Acad\u00e9mie : Versaille<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Buc\" de la commune de Buc. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me\/4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Buc\" de la commune de Buc.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me\/4\u00e8me \u2022 2020-2021-2022","location":{"lat":"48.77005978962952","lng":"2.1212009694822163","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-martin-luther-king\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me\/4\u00e8me \u2022 2020-2021-2022","post_content":"<h2>Coll\u00e8ge Martin Luther King<\/h2>\n<p>Commune : Buc<br \/>Acad\u00e9mie : Versaille<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Buc\" de la commune de Buc. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_5_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me\/4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Buc\" de la commune de Buc.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_5_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Coll\u00e8ge Martin Luther King","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-martin-luther-king\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.77005978962952","%_wpgmp_metabox_longitude%":"2.1212009694822163","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_5#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4361,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Quai Charles de Gaulle","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Quai Charles de Gaulle<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Carri\u00e8res-sur-Seine \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Quai Charles de Gaulle\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/Photo_Site-PAL_20_21_V_7-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Quai Charles de Gaulle<\/h2>\n<p>Latitude : 48.9054264\u00b0N | Longitude : 2.1807760\u00b0E<br \/>Commune : Carri\u00e8res-sur-Seine\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"Carri\u00e8res-sur-Seine \u2022 2020-2021-2022","location":{"lat":"48.905426431126074","lng":"2.1807760000229726","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/quai-charles-de-gaulle\/","zoom":7,"extra_fields":{"post_excerpt":"Carri\u00e8res-sur-Seine \u2022 2020-2021-2022","post_content":"<h2 class=\"site\">Quai Charles de Gaulle<\/h2>\n<p>Latitude : 48.9054264\u00b0N | Longitude : 2.1807760\u00b0E<br \/>Commune : Carri\u00e8res-sur-Seine\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Quai Charles de Gaulle","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/quai-charles-de-gaulle\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Quai Charles de Gaulle\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/Photo_Site-PAL_20_21_V_7-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.905426431126074","%_wpgmp_metabox_longitude%":"2.1807760000229726","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_7","%_wp_page_template%":"default","%_thumbnail_id%":"4353","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4364,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Lakanal","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Lakanal<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Lakanal\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/Photo_Classe_PAL_20_21_V_7-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Lakanal<\/h2>\n\n<p>Commune : Colombes<br \/>Acad\u00e9mie : Versaille<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Quai Charles de Gaulle\" de la commune du Carri\u00e8res-sur-Seine. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Quai Charles de Gaulle\" de la commune du Carri\u00e8res-sur-Seine.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2020-2021-2022","location":{"lat":"48.92360891190266","lng":"2.2518218020146783","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-lakanal\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2020-2021-2022","post_content":"<h2>Coll\u00e8ge Lakanal<\/h2>\n\n<p>Commune : Colombes<br \/>Acad\u00e9mie : Versaille<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Quai Charles de Gaulle\" de la commune du Carri\u00e8res-sur-Seine. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_7_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Quai Charles de Gaulle\" de la commune du Carri\u00e8res-sur-Seine.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_7_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Coll\u00e8ge Lakanal","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-lakanal\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Lakanal\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/Photo_Classe_PAL_20_21_V_7-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.92360891190266","%_wpgmp_metabox_longitude%":"2.2518218020146783","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_7#","%_wp_page_template%":"default","%_thumbnail_id%":"4354","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4365,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Guyancourt","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Guyancourt<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Guyancourt \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Guyancourt<\/h2>\n<p>Latitude : 48.96887\u00b0N | Longitude : 1.686656847\u00b0E<br \/>Commune : Guyancourt<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"Guyancourt \u2022 2021-2022","location":{"lat":"48.96887968874861","lng":"1.6866568474675154","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-guyancourt\/","zoom":7,"extra_fields":{"post_excerpt":"Guyancourt \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Guyancourt<\/h2>\n<p>Latitude : 48.96887\u00b0N | Longitude : 1.686656847\u00b0E<br \/>Commune : Guyancourt<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_V_2_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Berge de Guyancourt","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-guyancourt\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.96887968874861","%_wpgmp_metabox_longitude%":"1.6866568474675154","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_2","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4786,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Ren\u00e9 Cassin","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Ren\u00e9 Cassin<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Ren\u00e9 Cassin<\/h2>\n\n<p>Commune : Arpajon<br \/>Acad\u00e9mie : Versaille<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de lyc\u00e9e et BTS<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Sully\" de la commune de Sully-sur-Loire. Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de l'ile aux Moines\" de la commune de Marolles sur Seine.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2020-2021-2022","location":{"lat":"48.59485247763662","lng":"2.240258944723033","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-rene-cassin\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2020-2021-2022","post_content":"<h2>Lyc\u00e9e Ren\u00e9 Cassin<\/h2>\n\n<p>Commune : Arpajon<br \/>Acad\u00e9mie : Versaille<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de lyc\u00e9e et BTS<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Sully\" de la commune de Sully-sur-Loire. Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de l'ile aux Moines\" de la commune de Marolles sur Seine.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Lyc\u00e9e Ren\u00e9 Cassin","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-rene-cassin\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.59485247763662","%_wpgmp_metabox_longitude%":"2.240258944723033","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_1#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4359,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Chemin de Halage","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Chemin de Halage<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coudray-Montceaux \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chemin de Halage\" width=\"190\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6_Photo_Pollutionsite-190x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Chemin de Halage<\/h2>\n<p>Latitude : 48.569679\u00b0N | Longitude : 2.51081\u00b0E<br \/>Commune : Le Coudray-Montceaux\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<p>Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"Coudray-Montceaux \u2022 2020-2021-2022","location":{"lat":"48.569679","lng":"2.51081","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/chemin-de-halage-2\/","zoom":7,"extra_fields":{"post_excerpt":"Coudray-Montceaux \u2022 2020-2021-2022","post_content":"<h2 class=\"site\">Chemin de Halage<\/h2>\n<p>Latitude : 48.569679\u00b0N | Longitude : 2.51081\u00b0E<br \/>Commune : Le Coudray-Montceaux\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<p>Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Chemin de Halage","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/chemin-de-halage-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chemin de Halage\" width=\"190\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6_Photo_Pollutionsite-190x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.569679","%_wpgmp_metabox_longitude%":"2.51081","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_6","%_wp_page_template%":"default","%_thumbnail_id%":"4352","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4362,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Jean-Baptiste Corot","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Jean-Baptiste Corot<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Jean-Baptiste Corot<\/h2>\n<p>Commune : Savigny-sur-Orge<br \/>Acad\u00e9mie : Versaille<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Halage\" de la commune du Coudray-Montceaux. Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Halage\" de la commune du Coudray-Montceaux.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2020-2021-2022","location":{"lat":"48.674599125845965","lng":"2.3542472541368813","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-jean-baptiste-corot\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2020-2021-2022","post_content":"<h2>Lyc\u00e9e Jean-Baptiste Corot<\/h2>\n<p>Commune : Savigny-sur-Orge<br \/>Acad\u00e9mie : Versaille<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Halage\" de la commune du Coudray-Montceaux. Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Halage\" de la commune du Coudray-Montceaux.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_6_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Lyc\u00e9e Jean-Baptiste Corot","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-jean-baptiste-corot\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.674599125845965","%_wpgmp_metabox_longitude%":"2.3542472541368813","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_6#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4363,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Etang de Hollande","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Etang de Hollande<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Les Br\u00e9viaires \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Etang de Hollande<\/h2>\n<p>Latitude : 48.73117\u00b0N | Longitude : 1.79747\u00b0E<br \/>Commune : Les Br\u00e9viaires<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<p>Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p><\/div><\/div>","content":"Les Br\u00e9viaires \u2022 2021-2022","location":{"lat":"48.73117","lng":"1.79747","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/etang-de-hollande\/","zoom":7,"extra_fields":{"post_excerpt":"Les Br\u00e9viaires \u2022 2021-2022","post_content":"<h2 class=\"site\">Etang de Hollande<\/h2>\n<p>Latitude : 48.73117\u00b0N | Longitude : 1.79747\u00b0E<br \/>Commune : Les Br\u00e9viaires<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<p>Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p>","post_title":"Etang de Hollande","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/etang-de-hollande\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.73117","%_wpgmp_metabox_longitude%":"1.79747","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_4","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4788,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Saint Simon","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Saint Simon<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Saint Simon<\/h2>\n\n<p>Commune\u00a0: Jouars-Pontchartrain<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>60 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Etang de Hollande\" de la commune des Br\u00e9viaires. Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"48.805034292855446","lng":"1.8898825018962686","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-simon\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Saint Simon<\/h2>\n\n<p>Commune\u00a0: Jouars-Pontchartrain<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>60 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Etang de Hollande\" de la commune des Br\u00e9viaires. Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p>","post_title":"Coll\u00e8ge Saint Simon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-simon\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.805034292855446","%_wpgmp_metabox_longitude%":"1.8898825018962686","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_4#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4789,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Nanterre","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Nanterre<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Nanterre \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Nanterre<\/h2>\n<p>Latitude : 48.91339627\u00b0N | Longitude : 2.2109841\u00b0E<br \/>Commune : Nanterre<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<p>Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p><\/div><\/div>","content":"Nanterre \u2022 2021-2022","location":{"lat":"48.9133962722302","lng":"2.2109841359563775","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-nanterre\/","zoom":7,"extra_fields":{"post_excerpt":"Nanterre \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Nanterre<\/h2>\n<p>Latitude : 48.91339627\u00b0N | Longitude : 2.2109841\u00b0E<br \/>Commune : Nanterre<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<p>Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p>","post_title":"Berge de Nanterre","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-nanterre\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.9133962722302","%_wpgmp_metabox_longitude%":"2.2109841359563775","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_9","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4790,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Fran\u00e7ois Truffaut","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Fran\u00e7ois Truffaut<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Fran\u00e7ois Truffaut<\/h2>\n\n<p>Commune\u00a0: Asni\u00e8res Sur Seine<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>40 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Nanterre\" de la commune de Nanterre. Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022","location":{"lat":"48.9107940812606","lng":"2.283122457724256","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-francois-truffaut\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Fran\u00e7ois Truffaut<\/h2>\n\n<p>Commune\u00a0: Asni\u00e8res Sur Seine<br>Acad\u00e9mie : Versailles<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>40 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Nanterre\" de la commune de Nanterre. Les r\u00e9sultats seront mis en ligne avant avril 2022<\/p>","post_title":"Coll\u00e8ge Fran\u00e7ois Truffaut","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-francois-truffaut\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.9107940812606","%_wpgmp_metabox_longitude%":"2.283122457724256","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_21-22_V_9#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4791,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Albert Thierry","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Albert Thierry<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \u2022 2019-2020-2021\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Albert Thierry\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Albert Thierry<\/h2>\n\n<p>Commune : Limay<br \/>Acad\u00e9mie : Versaille<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de loisirs des boucles de Seine\" de la commune de Moisson.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>23 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Reserve naturelle r\u00e9gionale de Limay\" de la commune de Limay.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2019-2020-2021","location":{"lat":"48.997653722026435","lng":"1.7481992290096064","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-albert-thierry\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2019-2020-2021","post_content":"<h2>Coll\u00e8ge Albert Thierry<\/h2>\n\n<p>Commune : Limay<br \/>Acad\u00e9mie : Versaille<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de loisirs des boucles de Seine\" de la commune de Moisson.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_3_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>23 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Reserve naturelle r\u00e9gionale de Limay\" de la commune de Limay.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Coll\u00e8ge Albert Thierry","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-albert-thierry\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Albert Thierry\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.997653722026435","%_wpgmp_metabox_longitude%":"1.7481992290096064","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"35\";}","%refpoint%":"PAL_19-20_V_8#","%_thumbnail_id%":"1749","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020, 2020-2021"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4357,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020","2020-2021"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de l&rsquo;ile aux Moines","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Plage de l&rsquo;ile aux Moines<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Marolles sur Seine \u2022 2020-2021\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de l&rsquo;ile aux Moines\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1-Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de l'ile aux Moines<\/h2>\n<p>Latitude : 48.391883\u00b0N | Longitude : 3.049026\u00b0E<br \/>Commune : Marolles sur Seine\/p>\n\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"Marolles sur Seine \u2022 2020-2021","location":{"lat":"48.391883","lng":"3.049026","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-lile-aux-moines-2\/","zoom":7,"extra_fields":{"post_excerpt":"Marolles sur Seine \u2022 2020-2021","post_content":"<h2 class=\"site\">Plage de l'ile aux Moines<\/h2>\n<p>Latitude : 48.391883\u00b0N | Longitude : 3.049026\u00b0E<br \/>Commune : Marolles sur Seine\/p>\n\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Plage de l&rsquo;ile aux Moines","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-lile-aux-moines-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de l&rsquo;ile aux Moines\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1-Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.391883","%_wpgmp_metabox_longitude%":"3.049026","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_20-21_V_1","%_thumbnail_id%":"4349","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4358,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Reserve naturelle r\u00e9gionale de Limay","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Reserve naturelle r\u00e9gionale de Limay<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Limay \u2022 2019-2020\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Reserve naturelle r\u00e9gionale de Limay<\/h2>\n<p>Latitude : 49.0025\u00b0N | Longitude : 1.7502778\u00b0E<br \/>Commune : Limay\/p>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"Limay \u2022 2019-2020","location":{"lat":"49.0025","lng":"1.7502778","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/reserve-naturelle-regionale-de-limay\/","zoom":7,"extra_fields":{"post_excerpt":"Limay \u2022 2019-2020","post_content":"<h2 class=\"site\">Reserve naturelle r\u00e9gionale de Limay<\/h2>\n<p>Latitude : 49.0025\u00b0N | Longitude : 1.7502778\u00b0E<br \/>Commune : Limay\/p>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_V_8_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Reserve naturelle r\u00e9gionale de Limay","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/reserve-naturelle-regionale-de-limay\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"49.0025","%_wpgmp_metabox_longitude%":"1.7502778","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"35\";}","%refpoint%":"PAL_19-20_V_8","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4356,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Versailles","id":"35","type":"category","extension_fields":{"cat_order":"0"}}]}],"listing":{"listing_header":"<div id=\"explicatif\" style=\"margin: 10px 10px 10px 0;\">2019 \u00e0 2023 : r\u00e9sultats&nbsp;disponibles<\/div>\r\n<div id=\"legende\"><img class=\"wp-image-520\" style=\"width: 15px; height:15px; display:inline; vertical-align:bottom;\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/06\/maker-classe.png\" alt=\"\"> Classes&nbsp;&nbsp;<img class=\"wp-image-520\" style=\"width: 15px; height:15px; display:inline; vertical-align:bottom;\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/09\/maker-site-2.png\" alt=\"\"> Sites | Filtres&nbsp;:<\/div>","display_search_form":false,"search_field_autosuggest":false,"display_category_filter":false,"display_sorting_filter":false,"display_radius_filter":false,"radius_dimension":"miles","apply_default_radius":false,"default_radius_dimension":"miles","display_location_per_page_filter":false,"display_print_option":false,"display_grid_option":false,"filters":["place_category"],"sorting_options":{"category__asc":"A-Z Category","category__desc":"Z-A Category","title__asc":"A-Z Title","title__desc":"Z-A Title","address__asc":"A-Z Address","address__desc":"Z-A Address"},"default_sorting":{"orderby":"title","inorder":"asc"},"listing_container":".location_listing3","tabs_container":".location_listing3","hide_locations":true,"filters_position":"top_map","hide_map":false,"pagination":{"listing_per_page":10},"list_grid":"wpgmp_listing_list","listing_placeholder":"<div class=\"wpgmp_locations\">\r\n<div class=\"wpgmp_locations_head\">\r\n<div class=\"wpgmp_location_title\">\r\n<a href=\"\" class=\"place_title\" data-zoom=\"{marker_zoom}\" data-marker=\"{marker_id}\">{marker_title}<\/a>\r\n<\/div>\r\n<div class=\"wpgmp_location_meta\">\r\n<span class=\"wpgmp_location_category fc-badge info\">{marker_category}<\/span>\r\n<\/div>\r\n<\/div>\r\n<div class=\"wpgmp_locations_content\">\r\n{marker_message}\r\n<\/div>\r\n<div class=\"wpgmp_locations_foot\"><\/div>\r\n<p style=\"text-align:center;\"><a href=\"{post_link}\" target=\"_self\">EN SAVOIR PLUS<\/a><\/p>\r\n<\/div>","list_item_skin":{"name":"default","type":"item","sourcecode":"<div class=\"wpgmp_locations\">\r\n<div class=\"wpgmp_locations_head\">\r\n<div class=\"wpgmp_location_title\">\r\n<a href=\"\" class=\"place_title\" data-zoom=\"{marker_zoom}\" data-marker=\"{marker_id}\">{marker_title}<\/a>\r\n<\/div>\r\n<div class=\"wpgmp_location_meta\">\r\n<span class=\"wpgmp_location_category fc-badge info\">{marker_category}<\/span>\r\n<\/div>\r\n<\/div>\r\n<div class=\"wpgmp_locations_content\">\r\n{marker_message}\r\n<\/div>\r\n<div class=\"wpgmp_locations_foot\"><\/div>\r\n<p style=\"text-align:center;\"><a href=\"{post_link}\" target=\"_self\">EN SAVOIR PLUS<\/a><\/p>\r\n<\/div>"}},"map_property":{"map_id":"3","debug_mode":false},"shapes":{"drawing_editable":false},"filters":{"custom_filters":{"filters":{"dropdown":{"%type-site-classe%":"Sites et classes","%etude%":"Type de pollution","%annee%":"Ann\u00e9e"}}},"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"1":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","2":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","3":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","4":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","5":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","6":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","7":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","8":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","9":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","10":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","11":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","12":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","13":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","14":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","15":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","16":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","17":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","18":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","19":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","20":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","21":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","22":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","23":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","24":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","25":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","26":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","27":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","28":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","29":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","30":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","31":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","32":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","33":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","34":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","35":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","36":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","37":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe-en-cours.png","38":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-en-cours.png","40":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png"}}