Académie de Nantes

Académie de Nantes
Accompagnement académique

IPR Référent : Nathalie Dupré
Contacts : Fabrice Dholland, fabrice.dholland@ac-nantes.fr

{"map_options":{"center_lat":"47.849457","center_lng":"-0.952594","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":"Ch\u00e2teau-Gontier","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\">Ch\u00e2teau-Gontier<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Pornic \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 id=\"contenu_article\"><h2 class=\"site\">Ch\u00e2teau-Gontier<\/h2>\n<p>Latitude : 47.849457N | Longitude : 0.952594W<br \/>Commune : Pornic<\/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_Na-68_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul><\/div><\/div>","content":"Pornic \u2022 2022-2023","address":"","location":{"lat":"47.849457","lng":"-0.952594","redirect_custom_link":"","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/chateau-gontier\/","zoom":7,"extra_fields":{"post_excerpt":"Pornic \u2022 2022-2023","post_content":"<h2 class=\"site\">Ch\u00e2teau-Gontier<\/h2>\n<p>Latitude : 47.849457N | Longitude : 0.952594W<br \/>Commune : Pornic<\/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_Na-68_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>","post_title":"Ch\u00e2teau-Gontier","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/chateau-gontier\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.849457","%_wpgmp_metabox_longitude%":"-0.952594","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_68","%_wp_page_template%":"default","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":10518,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Volney","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 Volney<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\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 id=\"contenu_article\"><h2>Coll\u00e8ge Volney<\/h2>\n<p>Commune\u00a0: Craon<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>20 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ch\u00e2teau-Gontier\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-68_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2022-2023","location":{"lat":"47.84345468334362","lng":"-0.9426145302931452","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-volney\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Volney<\/h2>\n<p>Commune\u00a0: Craon<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>20 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ch\u00e2teau-Gontier\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-68_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Volney","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-volney\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.84345468334362","%_wpgmp_metabox_longitude%":"-0.9426145302931452","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_68#","%_wp_page_template%":"default","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":10519,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Savary de Maul\u00e9on","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 Savary de Maul\u00e9on<\/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 Savary de Maul\u00e9on\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-49-RamassagePlage-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Savary de Maul\u00e9on<\/h2>\n<p>Commune\u00a0: Les Sables d'Olonne<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>27 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Anse de Chaill\u00e9\" de la commune de Saint Nazaire.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-49_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>50 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Anse de Chaill\u00e9\" de la commune des Sables d\u2019Olonne.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_49_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\/07\/PAL_21-22_Na_49_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\/07\/PAL_21-22_Na_49_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2021-2022-2023","location":{"lat":"46.50558194651881","lng":"-1.7767756869911895","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-savary-de-mauleon\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2021-2022-2023","post_content":"<h2>Lyc\u00e9e Savary de Maul\u00e9on<\/h2>\n<p>Commune\u00a0: Les Sables d'Olonne<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>27 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Anse de Chaill\u00e9\" de la commune de Saint Nazaire.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-49_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>50 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Anse de Chaill\u00e9\" de la commune des Sables d\u2019Olonne.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_49_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\/07\/PAL_21-22_Na_49_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\/07\/PAL_21-22_Na_49_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Savary de Maul\u00e9on","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-savary-de-mauleon\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e Savary de Maul\u00e9on\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-49-RamassagePlage-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.50558194651881","%_wpgmp_metabox_longitude%":"-1.7767756869911895","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_49#","%_wp_page_template%":"default","%_thumbnail_id%":"11234","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":7244,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Anse de Chaill\u00e9","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\">Anse de Chaill\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Les Sables d\u2019Olonne \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=\"Anse de Chaill\u00e9\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-49-PhotoSite-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Anse de Chaill\u00e9<\/h2>\n<p>Latitude : 46.511941\u00b0N | Longitude : 1.817997\u00b0W<br \/>Commune : Les Sables d\u2019Olonne<\/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_Na-49_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_49_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\/07\/PAL_21-22_Na_49_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\/07\/PAL_21-22_Na_49_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Les Sables d\u2019Olonne \u2022 2021-2022-2023","location":{"lat":"46.511941","lng":"-1.817997","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/anse-de-chaille\/","zoom":7,"extra_fields":{"post_excerpt":"Les Sables d\u2019Olonne \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Anse de Chaill\u00e9<\/h2>\n<p>Latitude : 46.511941\u00b0N | Longitude : 1.817997\u00b0W<br \/>Commune : Les Sables d\u2019Olonne<\/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_Na-49_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_49_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\/07\/PAL_21-22_Na_49_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\/07\/PAL_21-22_Na_49_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Anse de Chaill\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/anse-de-chaille\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Anse de Chaill\u00e9\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-49-PhotoSite-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.511941","%_wpgmp_metabox_longitude%":"-1.817997","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_49","%_wp_page_template%":"default","%_thumbnail_id%":"11233","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":7243,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du Veillon","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 du Veillon<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Talmont Saint-Hilaire \u2022 2019-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=\"Plage du Veillon\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_6_photo_site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage du Veillon<\/h2>\n<p>Latitude : 46.434\u00b0N | Longitude : 1.659\u00b0W<br \/>Commune : Talmont Saint-Hilaire<\/p>\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_Na_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_6_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_Na_6_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_Na_6_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Talmont Saint-Hilaire \u2022 2019-2020\/2021-2022","location":{"lat":"46.434","lng":"-1.659","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-veillon\/","zoom":7,"extra_fields":{"post_excerpt":"Talmont Saint-Hilaire \u2022 2019-2020\/2021-2022","post_content":"<h2 class=\"site\">Plage du Veillon<\/h2>\n<p>Latitude : 46.434\u00b0N | Longitude : 1.659\u00b0W<br \/>Commune : Talmont Saint-Hilaire<\/p>\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_Na_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_6_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_Na_6_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_Na_6_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage du Veillon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-veillon\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage du Veillon\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_6_photo_site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.434","%_wpgmp_metabox_longitude%":"-1.659","%_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:\"22\";}","%refpoint%":"PAL_19-20_Na_6","%_wp_page_template%":"default","%_thumbnail_id%":"1603","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7171,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020","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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge St Paul","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 St Paul<\/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 St Paul<\/h2>\n<p>Commune\u00a0: Ste Hermine<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>80 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Veillon\" de la commune Talmont Saint-Hilaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2021-2022","location":{"lat":"46.5577997575964","lng":"-1.0541056999597718","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-st-paul\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge St Paul<\/h2>\n<p>Commune\u00a0: Ste Hermine<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>80 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Veillon\" de la commune Talmont Saint-Hilaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge St Paul","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-st-paul\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.5577997575964","%_wpgmp_metabox_longitude%":"-1.0541056999597718","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_6#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7173,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Crique du perroquet","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\">Crique du perroquet<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Pornic \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=\"Crique du perroquet\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na_67_1-Photosite2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Crique du perroquet <\/h2>\n<p>Latitude : 47.10638N | Longitude : 2.09671W<br \/>Commune : Pornic<\/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_Na-67_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_Na-67_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Pornic \u2022 2022-2023","location":{"lat":"47.10638","lng":"-2.09671","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/crique-du-perroquet\/","zoom":7,"extra_fields":{"post_excerpt":"Pornic \u2022 2022-2023","post_content":"<h2 class=\"site\">Crique du perroquet <\/h2>\n<p>Latitude : 47.10638N | Longitude : 2.09671W<br \/>Commune : Pornic<\/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_Na-67_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_Na-67_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Crique du perroquet","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/crique-du-perroquet\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Crique du perroquet\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na_67_1-Photosite2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.10638","%_wpgmp_metabox_longitude%":"-2.09671","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_67","%_thumbnail_id%":"11208","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":11259,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lycee Polyvalent Sacr\u00e9 Coeur","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\">Lycee Polyvalent Sacr\u00e9 Coeur<\/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=\"Lycee Polyvalent Sacr\u00e9 Coeur\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na_67_6-CathegorieMacro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lycee Polyvalent Sacr\u00e9 Coeur<\/h2>\n<p>Commune\u00a0: Nantes<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9co-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Crique du perroquet \".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-67_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_Na-67_FS.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 2022-2023","location":{"lat":"47.20750662022473","lng":"-1.6086471591662705","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-polyvalent-sacre-coeur\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","post_content":"<h2>Lycee Polyvalent Sacr\u00e9 Coeur<\/h2>\n<p>Commune\u00a0: Nantes<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9co-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Crique du perroquet \".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-67_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_Na-67_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Lycee Polyvalent Sacr\u00e9 Coeur","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-polyvalent-sacre-coeur\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lycee Polyvalent Sacr\u00e9 Coeur\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na_67_6-CathegorieMacro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.20750662022473","%_wpgmp_metabox_longitude%":"-1.6086471591662705","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_67#","%_thumbnail_id%":"11209","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":11260,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Beau rivage","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 Beau rivage<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Reze \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=\"Plage de Beau rivage\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na58_1_photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Beau rivage<\/h2>\n<p>Latitude : 47.1963832N | Longitude : 1.57719731W<br \/>Commune : Reze<\/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-Na-58FM.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-Na-58FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Reze \u2022 2022-2023","location":{"lat":"47.1963832","lng":"-1.57719731","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-beau-rivage-2\/","zoom":7,"extra_fields":{"post_excerpt":"Reze \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage de Beau rivage<\/h2>\n<p>Latitude : 47.1963832N | Longitude : 1.57719731W<br \/>Commune : Reze<\/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-Na-58FM.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-Na-58FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage de Beau rivage","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-beau-rivage-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Beau rivage\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na58_1_photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.1963832","%_wpgmp_metabox_longitude%":"-1.57719731","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_58","%_wp_page_template%":"default","%_thumbnail_id%":"11220","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":8537,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Port Barbe","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\">Port Barbe<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                La Chapelle-sur-Erdre \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=\"Port Barbe\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na-61-Zone-de-prelevement-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Port Barbe<\/h2>\n<p>Latitude : 47.2646272N | Longitude : 1.539879594W<br \/>Commune : La Chapelle-sur-Erdre<\/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-Na-61FM.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-Na-61FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"La Chapelle-sur-Erdre \u2022 2022-2023","location":{"lat":"47.264627225418565","lng":"-1.5398795940139367","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/port-barbe\/","zoom":7,"extra_fields":{"post_excerpt":"La Chapelle-sur-Erdre \u2022 2022-2023","post_content":"<h2 class=\"site\">Port Barbe<\/h2>\n<p>Latitude : 47.2646272N | Longitude : 1.539879594W<br \/>Commune : La Chapelle-sur-Erdre<\/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-Na-61FM.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-Na-61FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Port Barbe","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/port-barbe\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Port Barbe\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na-61-Zone-de-prelevement-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.264627225418565","%_wpgmp_metabox_longitude%":"-1.5398795940139367","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_61","%_wp_page_template%":"default","%_thumbnail_id%":"11222","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":8543,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge La Coutanci\u00e8re","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 La Coutanci\u00e8re<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\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 La Coutanci\u00e8re\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na-61-macro-meso-225x300.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge La Coutanci\u00e8re<\/h2>\n<p>Commune\u00a0: La Chapelle-sur-Erdre<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>130 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Port Barbe\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-61FM.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-Na-61FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2022-2023","location":{"lat":"47.30838499883641","lng":"-1.5617859020848661","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-la-coutanciere\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge La Coutanci\u00e8re<\/h2>\n<p>Commune\u00a0: La Chapelle-sur-Erdre<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>130 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Port Barbe\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-61FM.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-Na-61FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge La Coutanci\u00e8re","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-la-coutanciere\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge La Coutanci\u00e8re\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na-61-macro-meso-225x300.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.30838499883641","%_wpgmp_metabox_longitude%":"-1.5617859020848661","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_61#","%_wp_page_template%":"default","%_thumbnail_id%":"11221","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":8544,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Embouchure du Pigray","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\">Embouchure du Pigray<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint-Loup-du-Gast \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=\"Embouchure du Pigray\" width=\"160\" height=\"120\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na62-1_Photo_Site1.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Embouchure du Pigray<\/h2>\n<p>Latitude : 48.3694472N | Longitude : 0.5926844W<br \/>Commune : Saint-Loup-du-Gast<\/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_Na-62_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_Na-62_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint-Loup-du-Gast \u2022 2022-2023","location":{"lat":"48.369447208182855","lng":"-0.5926844016163413","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/embouchure-du-pigray\/","zoom":7,"extra_fields":{"post_excerpt":"Saint-Loup-du-Gast \u2022 2022-2023","post_content":"<h2 class=\"site\">Embouchure du Pigray<\/h2>\n<p>Latitude : 48.3694472N | Longitude : 0.5926844W<br \/>Commune : Saint-Loup-du-Gast<\/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_Na-62_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_Na-62_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Embouchure du Pigray","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/embouchure-du-pigray\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Embouchure du Pigray\" width=\"160\" height=\"120\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na62-1_Photo_Site1.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.369447208182855","%_wpgmp_metabox_longitude%":"-0.5926844016163413","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_62","%_wp_page_template%":"default","%_thumbnail_id%":"11223","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":8545,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge S\u00e9vign\u00e9","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 S\u00e9vign\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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 S\u00e9vign\u00e9\" width=\"160\" height=\"120\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na62-1_Photo_Site4.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge S\u00e9vign\u00e9<\/h2>\n<p>Commune\u00a0: Mayenne<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>12 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Embouchure du Pigray\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-62_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_Na-62_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2022-2023","location":{"lat":"48.30557931594994","lng":"-0.6245593211017874","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-sevigne\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge S\u00e9vign\u00e9<\/h2>\n<p>Commune\u00a0: Mayenne<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>12 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Embouchure du Pigray\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-62_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_Na-62_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge S\u00e9vign\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-sevigne\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge S\u00e9vign\u00e9\" width=\"160\" height=\"120\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na62-1_Photo_Site4.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.30557931594994","%_wpgmp_metabox_longitude%":"-0.6245593211017874","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_62#","%_wp_page_template%":"default","%_thumbnail_id%":"11224","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":8546,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Pont de Prunier (aire pique-nique)","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\">Pont de Prunier (aire pique-nique)<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Bouchemaine \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 id=\"contenu_article\"><h2 class=\"site\">Pont de Prunier (aire pique-nique)<\/h2>\n<p>Latitude : 47.448864N | Longitude : 0.594668W<br \/>Commune : Bouchemaine<\/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_Na-63_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_Na-63_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Bouchemaine \u2022 2022-2023","location":{"lat":"47.448864","lng":"-0.594668","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-prunier-aire-pique-nique\/","zoom":7,"extra_fields":{"post_excerpt":"Bouchemaine \u2022 2022-2023","post_content":"<h2 class=\"site\">Pont de Prunier (aire pique-nique)<\/h2>\n<p>Latitude : 47.448864N | Longitude : 0.594668W<br \/>Commune : Bouchemaine<\/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_Na-63_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_Na-63_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Pont de Prunier (aire pique-nique)","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-prunier-aire-pique-nique\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.448864","%_wpgmp_metabox_longitude%":"-0.594668","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_63","%_wp_page_template%":"default","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":8547,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Jean Rostand","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 Jean Rostand<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\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 id=\"contenu_article\"><h2>Coll\u00e8ge Jean Rostand<\/h2>\n<p>Commune\u00a0: Tr\u00e9laz\u00e9<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>35 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Prunier (aire pique-nique)\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-63_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_Na-63_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h6>Valorisation<\/h6>\n<p>Article de presse : www.ouest-france.fr\/pays-de-la-loire\/trelaze-49800\/au-college-jean-rostand-le-plastique-a-la-loupe-2c089daf-7929-4f7a-b7fb-559efcd06a70<\/p>\n<p>Vid\u00e9o : www.youtube.com\/watch?v=cybDRyVqS_A<\/p><\/div><\/div>","content":"6\u00e8me \u2022 2022-2023","location":{"lat":"47.449514344973174","lng":"-0.5012480309161472","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-rostand-2\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Jean Rostand<\/h2>\n<p>Commune\u00a0: Tr\u00e9laz\u00e9<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>35 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Prunier (aire pique-nique)\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-63_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_Na-63_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h6>Valorisation<\/h6>\n<p>Article de presse : www.ouest-france.fr\/pays-de-la-loire\/trelaze-49800\/au-college-jean-rostand-le-plastique-a-la-loupe-2c089daf-7929-4f7a-b7fb-559efcd06a70<\/p>\n<p>Vid\u00e9o : www.youtube.com\/watch?v=cybDRyVqS_A<\/p>","post_title":"Coll\u00e8ge Jean Rostand","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-rostand-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_old_slug%":"college-jean-rostand-3","%_wpgmp_metabox_latitude%":"47.449514344973174","%_wpgmp_metabox_longitude%":"-0.5012480309161472","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_63#","%_wp_page_template%":"default","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":8548,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Base nautique Saint Jean de Monts","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\">Base nautique Saint Jean de Monts<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Jean de Monts \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=\"Base nautique Saint Jean de Monts\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23-Na64_1_Photo_Site2-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Base nautique Saint Jean de Monts<\/h2>\n<p>Latitude : 46.78880N | Longitude : 2.087963W<br \/>Commune : Saint Jean de Monts<\/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-Na-64FM.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-Na-64FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Saint Jean de Monts \u2022 2022-2023","location":{"lat":"46.788806","lng":"-2.087963","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/base-nautique-saint-jean-de-monts\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Jean de Monts \u2022 2022-2023","post_content":"<h2 class=\"site\">Base nautique Saint Jean de Monts<\/h2>\n<p>Latitude : 46.78880N | Longitude : 2.087963W<br \/>Commune : Saint Jean de Monts<\/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-Na-64FM.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-Na-64FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Base nautique Saint Jean de Monts","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/base-nautique-saint-jean-de-monts\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Base nautique Saint Jean de Monts\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23-Na64_1_Photo_Site2-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.788806","%_wpgmp_metabox_longitude%":"-2.087963","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_64","%_wp_page_template%":"default","%_thumbnail_id%":"11225","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":8549,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge St Jean Les Lauriers","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 St Jean Les Lauriers<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\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 St Jean Les Lauriers\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23-Na64_Photo_Recherche-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge St Jean Les Lauriers<\/h2>\n<p>Commune\u00a0: Saint Jean de Monts<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>60 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \"Base nautique Saint Jean de Monts\" et \"Plage de Saint Jean de Monts\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-64FM.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-Na-64FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-65FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2022-2023","location":{"lat":"46.79472341702445","lng":"-2.0626606174475537","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-st-jean-les-lauriers\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge St Jean Les Lauriers<\/h2>\n<p>Commune\u00a0: Saint Jean de Monts<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>60 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \"Base nautique Saint Jean de Monts\" et \"Plage de Saint Jean de Monts\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-64FM.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-Na-64FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-65FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge St Jean Les Lauriers","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-st-jean-les-lauriers\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge St Jean Les Lauriers\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23-Na64_Photo_Recherche-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.79472341702445","%_wpgmp_metabox_longitude%":"-2.0626606174475537","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_64#","%_wp_page_template%":"default","%_thumbnail_id%":"11226","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":8550,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Saint Jean de Monts","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 Saint Jean de Monts<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Jean de Monts \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=\"Plage de Saint Jean de Monts\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23-Na65_1_Photo_Site1-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Saint Jean de Monts<\/h2>\n<p>Latitude : 46.785623N | Longitude : 2.081504W<br \/>Commune : Saint Jean de Monts<\/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-Na-65FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul><\/div><\/div>","content":"Saint Jean de Monts \u2022 2022-2023","location":{"lat":"46.785623","lng":"-2.081504","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-saint-jean-de-monts\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Jean de Monts \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage de Saint Jean de Monts<\/h2>\n<p>Latitude : 46.785623N | Longitude : 2.081504W<br \/>Commune : Saint Jean de Monts<\/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-Na-65FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>","post_title":"Plage de Saint Jean de Monts","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-saint-jean-de-monts\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Saint Jean de Monts\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23-Na65_1_Photo_Site1-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.785623","%_wpgmp_metabox_longitude%":"-2.081504","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_65","%_wp_page_template%":"default","%_thumbnail_id%":"11229","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":8551,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Chemin des Air\u00e9es","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 des Air\u00e9es<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Les Ponts-de-C\u00e9 \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=\"Chemin des Air\u00e9es\" width=\"200\" height=\"150\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na-57_1_Photo_Site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Chemin des Air\u00e9es<\/h2>\n<p>Latitude : 48.0469706\u00b0N | Longitude : 0.4186418\u00b0E<br \/>Commune : Les Ponts-de-C\u00e9<\/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-Na-57FM.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-Na-57FS.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_Na_57_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Les Ponts-de-C\u00e9 \u2022 2021-2022-2023","location":{"lat":"47.40643315881116","lng":"-0.5276992829803562","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/chemin-des-airees\/","zoom":7,"extra_fields":{"post_excerpt":"Les Ponts-de-C\u00e9 \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Chemin des Air\u00e9es<\/h2>\n<p>Latitude : 48.0469706\u00b0N | Longitude : 0.4186418\u00b0E<br \/>Commune : Les Ponts-de-C\u00e9<\/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-Na-57FM.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-Na-57FS.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_Na_57_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Chemin des Air\u00e9es","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/chemin-des-airees\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chemin des Air\u00e9es\" width=\"200\" height=\"150\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na-57_1_Photo_Site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.40643315881116","%_wpgmp_metabox_longitude%":"-0.5276992829803562","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_57","%_wp_page_template%":"default","%_thumbnail_id%":"11219","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":7253,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Pont de Prunier","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\">Pont de Prunier<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Bouchemaine \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 class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pont de Prunier\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-46-1_Photo_Site-vers-nord-Est-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Pont de Prunier<\/h2>\n<p>Latitude : 47.445065\u00b0N | Longitude : 0.5964597\u00b0W<br \/>Commune : Bouchemaine<\/p>\n\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-Na_46_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Bouchemaine \u2022 2021-2022","location":{"lat":"47.445065603739586","lng":"-0.596459700267388","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-prunier\/","zoom":7,"extra_fields":{"post_excerpt":"Bouchemaine \u2022 2021-2022","post_content":"<h2 class=\"site\">Pont de Prunier<\/h2>\n<p>Latitude : 47.445065\u00b0N | Longitude : 0.5964597\u00b0W<br \/>Commune : Bouchemaine<\/p>\n\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-Na_46_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Pont de Prunier","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-prunier\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pont de Prunier\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-46-1_Photo_Site-vers-nord-Est-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.445065603739586","%_wpgmp_metabox_longitude%":"-0.596459700267388","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_46","%_wp_page_template%":"default","%_thumbnail_id%":"11204","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7237,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"LP Saint Aubin la Salle","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\">LP Saint Aubin la Salle<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                1\u00e8re \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 class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"LP Saint Aubin la Salle\" width=\"256\" height=\"138\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-46-5_Photo_VracMacro.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>LP Saint Aubin la Salle<\/h2>\n<p>Commune\u00a0: Saint-Sylvain d'Anjou<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>9 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Prunier\" de la commune de Bouchemaine.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22-Na_46_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"1\u00e8re \u2022 2021-2022","location":{"lat":"47.489559525358615","lng":"-0.5029315636582008","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lp-saint-aubin-la-salle\/","zoom":7,"extra_fields":{"post_excerpt":"1\u00e8re \u2022 2021-2022","post_content":"<h2>LP Saint Aubin la Salle<\/h2>\n<p>Commune\u00a0: Saint-Sylvain d'Anjou<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>9 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Prunier\" de la commune de Bouchemaine.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22-Na_46_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"LP Saint Aubin la Salle","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lp-saint-aubin-la-salle\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"LP Saint Aubin la Salle\" width=\"256\" height=\"138\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-46-5_Photo_VracMacro.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.489559525358615","%_wpgmp_metabox_longitude%":"-0.5029315636582008","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_46#","%_wp_page_template%":"default","%_thumbnail_id%":"11205","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7238,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Saint Calais","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 Saint Calais<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Calais \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 Saint Calais\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Na-47-site-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Saint Calais<\/h2>\n<p>Latitude : 47.9170556\u00b0N | Longitude : 0.7438889\u00b0E<br \/>Commune : Saint Calais<\/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-Na-47FM.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-Na-47FS.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-Na_47_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint Calais \u2022 2021-2022-2023","location":{"lat":"47.9170556","lng":"0.7438889","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-saint-calais\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Calais \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Berge de Saint Calais<\/h2>\n<p>Latitude : 47.9170556\u00b0N | Longitude : 0.7438889\u00b0E<br \/>Commune : Saint Calais<\/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-Na-47FM.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-Na-47FS.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-Na_47_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Berge de Saint Calais","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-saint-calais\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Saint Calais\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Na-47-site-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.9170556","%_wpgmp_metabox_longitude%":"0.7438889","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_47","%_wp_page_template%":"default","%_thumbnail_id%":"11207","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":7239,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Fr\u00e8re Andr\u00e9","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 Fr\u00e8re Andr\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\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 Fr\u00e8re Andr\u00e9\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Na-47-classe-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Fr\u00e8re Andr\u00e9<\/h2>\n<p>Commune\u00a0: Saint Calais<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>47 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Calais\" de la commune de Saint Calais.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-47FM.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-Na-47FS.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>26 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Calais\" de la commune de Saint Calais.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/Pal-21-22-Na_47_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022-2023","location":{"lat":"47.916990237365894","lng":"0.7458538744177979","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-frere-andre\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022-2023","post_content":"<h2>Coll\u00e8ge Fr\u00e8re Andr\u00e9<\/h2>\n<p>Commune\u00a0: Saint Calais<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>47 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Calais\" de la commune de Saint Calais.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-47FM.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-Na-47FS.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>26 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Calais\" de la commune de Saint Calais.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/Pal-21-22-Na_47_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Fr\u00e8re Andr\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-frere-andre\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Fr\u00e8re Andr\u00e9\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Na-47-classe-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.916990237365894","%_wpgmp_metabox_longitude%":"0.7458538744177979","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_47#","%_wp_page_template%":"default","%_thumbnail_id%":"11206","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":7240,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Beau Rivage","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 Beau Rivage<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Rez\u00e9 \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=\"Plage de Beau Rivage\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_34-Photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Beau Rivage<\/h2>\n<p>Latitude : 47.19721469\u00b0N | Longitude : 1.573822428\u00b0W<br \/>Commune : Rez\u00e9<\/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-Na-34FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_34_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Rez\u00e9 \u2022 2021-2022-2023","location":{"lat":"47.19721469002728","lng":"-1.5738224285898759","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-beau-rivage\/","zoom":7,"extra_fields":{"post_excerpt":"Rez\u00e9 \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Plage de Beau Rivage<\/h2>\n<p>Latitude : 47.19721469\u00b0N | Longitude : 1.573822428\u00b0W<br \/>Commune : Rez\u00e9<\/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-Na-34FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_34_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage de Beau Rivage","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-beau-rivage\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Beau Rivage\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_34-Photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.19721469002728","%_wpgmp_metabox_longitude%":"-1.5738224285898759","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_34","%_wp_page_template%":"default","%_thumbnail_id%":"11239","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7218,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Pont Mah\u00e9","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 Pont Mah\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Penestin \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=\"Plage de Pont Mah\u00e9\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-35-photo-site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Pont Mah\u00e9<\/h2>\n<p>Latitude : 47.443701\u00b0N | Longitude : -2.45214334\u00b0W<br \/>Commune : Penestin<\/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-Na-35FM.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-Na-35FS.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_Na_35FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Penestin \u2022 2021-2022-2023","location":{"lat":"47.44370111930442","lng":"-2.4521433409798905","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-pont-mahe\/","zoom":7,"extra_fields":{"post_excerpt":"Penestin \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Plage de Pont Mah\u00e9<\/h2>\n<p>Latitude : 47.443701\u00b0N | Longitude : -2.45214334\u00b0W<br \/>Commune : Penestin<\/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-Na-35FM.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-Na-35FS.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_Na_35FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage de Pont Mah\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-pont-mahe\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Pont Mah\u00e9\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-35-photo-site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.44370111930442","%_wpgmp_metabox_longitude%":"-2.4521433409798905","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_35","%_wp_page_template%":"default","%_thumbnail_id%":"11203","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":7220,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Parc des Rochettes","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 des Rochettes<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Montaigu \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\">Parc des Rochettes<\/h2>\n<p>Latitude : 47.443701\u00b0N | Longitude : -2.45214334\u00b0W<br \/>Commune : Montaigu<\/p>\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_Na_36_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Montaigu \u2022 2021-2022","location":{"lat":"46.97874104817124","lng":"-1.3190591240844762","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/parc-des-rochettes\/","zoom":7,"extra_fields":{"post_excerpt":"Montaigu \u2022 2021-2022","post_content":"<h2 class=\"site\">Parc des Rochettes<\/h2>\n<p>Latitude : 47.443701\u00b0N | Longitude : -2.45214334\u00b0W<br \/>Commune : Montaigu<\/p>\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_Na_36_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Parc des Rochettes","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/parc-des-rochettes\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.97874104817124","%_wpgmp_metabox_longitude%":"-1.3190591240844762","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_36","%_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":7222,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Michel Ragon","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 Michel Ragon<\/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 Michel Ragon<\/h2>\n<p>Commune\u00a0: Saint Hilaire de Loulay<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>130 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Parc des Rochettes\" de la commune de Montaigu.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_36_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"46.98535204136311","lng":"-1.3090485446449194","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-michel-ragon\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Michel Ragon<\/h2>\n<p>Commune\u00a0: Saint Hilaire de Loulay<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>130 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Parc des Rochettes\" de la commune de Montaigu.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_36_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Michel Ragon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-michel-ragon\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.98535204136311","%_wpgmp_metabox_longitude%":"-1.3090485446449194","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_36#","%_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":7223,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage le Clos des Pins","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 le Clos des Pins<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Rochefort \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=\"Plage le Clos des Pins\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_39_1_Photo_Site-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage le Clos des Pins<\/h2>\n<p>Latitude : 46.3888042\u00b0N | Longitude : 1.4937392704\u00b0W<br \/>Commune : Longeville sur mer<\/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_Na-39_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_Na-39_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_Na_39FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Rochefort \u2022 2021-2022-2023","location":{"lat":"46.38880426586488","lng":"-1.4937392704952428","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-le-clos-des-pins\/","zoom":7,"extra_fields":{"post_excerpt":"Rochefort \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Plage le Clos des Pins<\/h2>\n<p>Latitude : 46.3888042\u00b0N | Longitude : 1.4937392704\u00b0W<br \/>Commune : Longeville sur mer<\/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_Na-39_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_Na-39_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_Na_39FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage le Clos des Pins","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-le-clos-des-pins\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage le Clos des Pins\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_39_1_Photo_Site-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.38880426586488","%_wpgmp_metabox_longitude%":"-1.4937392704952428","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_39","%_wp_page_template%":"default","%_thumbnail_id%":"11213","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":7226,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Golfe des Pictons","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 Golfe des Pictons<\/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 Golfe des Pictons\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_39_5_Photo_VracMacro-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Golfe des Pictons<\/h2>\n<p>Commune\u00a0: L'Ille d'Elle<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>50 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage le Clos des Pins\" de la commune de Longeville sur mer.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-39_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_Na-39_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>23 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage le Clos des Pins\" de la commune de Longeville sur mer.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_39FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022-2023","location":{"lat":"46.32891877369508","lng":"-0.9498503311723202","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-golfe-des-pictons\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022-2023","post_content":"<h2>Coll\u00e8ge Golfe des Pictons<\/h2>\n<p>Commune\u00a0: L'Ille d'Elle<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>50 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage le Clos des Pins\" de la commune de Longeville sur mer.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-39_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_Na-39_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>23 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage le Clos des Pins\" de la commune de Longeville sur mer.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_39FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Golfe des Pictons","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-golfe-des-pictons\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Golfe des Pictons\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_39_5_Photo_VracMacro-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.32891877369508","%_wpgmp_metabox_longitude%":"-0.9498503311723202","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_39#","%_wp_page_template%":"default","%_thumbnail_id%":"11214","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":7227,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du Petit Traict (Est)","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 du Petit Traict (Est)<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Nazaire \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=\"Plage du Petit Traict (Est)\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na-40_1_Photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage du Petit Traict (Est)<\/h2>\n<p>Latitude : 47.269825\u00b0N | Longitude : 2.211948\u00b0W<br \/>Commune : Saint Nazaire<\/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_Na-40_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_Na-40_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_Na_40_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint Nazaire \u2022 2021-2022-2023","location":{"lat":"47.269825","lng":"-2.211948","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-petit-traict-est\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Nazaire \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Plage du Petit Traict (Est)<\/h2>\n<p>Latitude : 47.269825\u00b0N | Longitude : 2.211948\u00b0W<br \/>Commune : Saint Nazaire<\/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_Na-40_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_Na-40_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_Na_40_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage du Petit Traict (Est)","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-petit-traict-est\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage du Petit Traict (Est)\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na-40_1_Photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.269825","%_wpgmp_metabox_longitude%":"-2.211948","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_40","%_wp_page_template%":"default","%_thumbnail_id%":"11217","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7228,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Carcouet","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 Carcouet<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \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 Carcouet\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na-40_1_Photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Carcouet<\/h2>\n<p>Commune\u00a0: Nantes<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Petit Traict (Est)\" de la commune de Saint Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-40_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_Na-40_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2022-2023","location":{"lat":"47.229956615593935","lng":"-1.5947151327773625","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-carcouet\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2022-2023","post_content":"<h2>Lyc\u00e9e Carcouet<\/h2>\n<p>Commune\u00a0: Nantes<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Petit Traict (Est)\" de la commune de Saint Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-40_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_Na-40_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Carcouet","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-carcouet\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e Carcouet\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na-40_1_Photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.229956615593935","%_wpgmp_metabox_longitude%":"-1.5947151327773625","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_40#","%_wp_page_template%":"default","%_thumbnail_id%":"11217","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":8508,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Port Charlotte","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 Port Charlotte<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Nazaire \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 id=\"contenu_article\"><h2 class=\"site\">Plage de Port Charlotte<\/h2>\n<p>Latitude : 47.243797\u00b0N | Longitude : 2.262388\u00b0W<br \/>Commune : Saint Nazaire<\/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-Na-43FS.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_Na_43FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint Nazaire \u2022 2021-2022-2023","location":{"lat":"47.243797","lng":"-2.262388","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-port-charlotte\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Nazaire \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Plage de Port Charlotte<\/h2>\n<p>Latitude : 47.243797\u00b0N | Longitude : 2.262388\u00b0W<br \/>Commune : Saint Nazaire<\/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-Na-43FS.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_Na_43FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage de Port Charlotte","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-port-charlotte\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.243797","%_wpgmp_metabox_longitude%":"-2.262388","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_43","%_wp_page_template%":"default","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":7231,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Albert Vin\u00e7on","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 Vin\u00e7on<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\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 Albert Vin\u00e7on\" width=\"300\" height=\"224\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_43_6_Photo_CategMacro-300x224.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Albert Vin\u00e7on<\/h2>\n<p>Commune\u00a0: Saint Nazaire<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>27 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Port Charlotte\" de la commune de Saint Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-43FS.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>26 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Port Charlotte\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_43FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2021-2022-2023","location":{"lat":"47.255411193468724","lng":"-2.25940810230574","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-albert-vincon\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2021-2022-2023","post_content":"<h2>Coll\u00e8ge Albert Vin\u00e7on<\/h2>\n<p>Commune\u00a0: Saint Nazaire<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>27 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Port Charlotte\" de la commune de Saint Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-43FS.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>26 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Port Charlotte\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_43FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Albert Vin\u00e7on","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-albert-vincon\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Albert Vin\u00e7on\" width=\"300\" height=\"224\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_43_6_Photo_CategMacro-300x224.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.255411193468724","%_wpgmp_metabox_longitude%":"-2.25940810230574","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_43#","%_wp_page_template%":"default","%_thumbnail_id%":"11216","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":7232,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"La Haie Traversaine","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\">La Haie Traversaine<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                La Haie Traversaine \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 id=\"contenu_article\"><h2 class=\"site\">La Haie Traversaine<\/h2>\n<p>Latitude : 48.372913\u00b0N | Longitude : 0.594500\u00b0W<br \/>Commune : La Haie Traversaine<\/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_Na-30_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_Na-30_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_Na_30_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\/07\/PAL_21-22_Na_30_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\/07\/PAL_21-22_Na_30_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"La Haie Traversaine \u2022 2021-2022-2023","location":{"lat":"48.372913","lng":"-0.594500","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/la-haie-traversaine\/","zoom":7,"extra_fields":{"post_excerpt":"La Haie Traversaine \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">La Haie Traversaine<\/h2>\n<p>Latitude : 48.372913\u00b0N | Longitude : 0.594500\u00b0W<br \/>Commune : La Haie Traversaine<\/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_Na-30_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_Na-30_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_Na_30_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\/07\/PAL_21-22_Na_30_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\/07\/PAL_21-22_Na_30_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"La Haie Traversaine","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/la-haie-traversaine\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.372913","%_wpgmp_metabox_longitude%":"-0.594500","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_30","%_wp_page_template%":"default","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":7214,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge L\u00e9o ferr\u00e9","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\u00e9o ferr\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\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 id=\"contenu_article\"><h2>Coll\u00e8ge L\u00e9o ferr\u00e9<\/h2>\n<p>Commune\u00a0: Ambrieres Les Vall\u00e9es<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>44 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"La Haie Traversaine\" de la commune de La Haie Traversaine. <\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-30_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_Na-30_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>16 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"La Haie Traversaine\" de la commune de La Haie Traversaine.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_30_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\/07\/PAL_21-22_Na_30_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\/07\/PAL_21-22_Na_30_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2021-2022-2023","location":{"lat":"48.397740995866435","lng":"-0.633053859936142","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-leo-ferre\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2021-2022-2023","post_content":"<h2>Coll\u00e8ge L\u00e9o ferr\u00e9<\/h2>\n<p>Commune\u00a0: Ambrieres Les Vall\u00e9es<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>44 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"La Haie Traversaine\" de la commune de La Haie Traversaine. <\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Na-30_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_Na-30_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>16 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"La Haie Traversaine\" de la commune de La Haie Traversaine.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_30_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\/07\/PAL_21-22_Na_30_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\/07\/PAL_21-22_Na_30_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge L\u00e9o ferr\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-leo-ferre\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.397740995866435","%_wpgmp_metabox_longitude%":"-0.633053859936142","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_30#","%_wp_page_template%":"default","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":7215,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Gabriel Deshayes","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 Gabriel Deshayes<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\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 Gabriel Deshayes\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_20-Photo_Categ-Macro-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Gabriel Deshayes<\/h2>\n<p>Commune\u00a0: Saint Gildas des Bois<br>Acad\u00e9mie : Nantes<\/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 \"Plage de Vill\u00e8s Martin\" de la commune de Saint Nazaire.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2022-2023","location":{"lat":"47.51775144215563","lng":"-2.041397059750018","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-gabriel-deshayes\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Gabriel Deshayes<\/h2>\n<p>Commune\u00a0: Saint Gildas des Bois<br>Acad\u00e9mie : Nantes<\/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 \"Plage de Vill\u00e8s Martin\" de la commune de Saint Nazaire.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Gabriel Deshayes","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-gabriel-deshayes\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Gabriel Deshayes\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_20-Photo_Categ-Macro-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.51775144215563","%_wpgmp_metabox_longitude%":"-2.041397059750018","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_20#","%_wp_page_template%":"default","%_thumbnail_id%":"11237","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":8476,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Sauveterre","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 Sauveterre<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Sables d'Olonne \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=\"Plage de Sauveterre\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na23-2_PhotoLaisse-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Sauveterre<\/h2>\n<p>Latitude : 46.553330\u00b0N | Longitude : 1.833437\u00b0W<br \/>Commune : Les Sables d'Olonne<\/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-Na-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Sables d'Olonne \u2022 2020-2021-2022-2023","location":{"lat":"46.553330","lng":"-1.833437","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-sauveterre\/","zoom":7,"extra_fields":{"post_excerpt":"Sables d'Olonne \u2022 2020-2021-2022-2023","post_content":"<h2 class=\"site\">Plage de Sauveterre<\/h2>\n<p>Latitude : 46.553330\u00b0N | Longitude : 1.833437\u00b0W<br \/>Commune : Les Sables d'Olonne<\/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-Na-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage de Sauveterre","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-sauveterre\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Sauveterre\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na23-2_PhotoLaisse-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.553330","%_wpgmp_metabox_longitude%":"-1.833437","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_23","%_wp_page_template%":"default","%_thumbnail_id%":"11228","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7202,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Jean Monnet","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 Jean Monnet<\/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 Jean Monnet\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Na-23_classe2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Jean Monnet<\/h2>\n<p>Commune : Sables d'Olonne<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>26 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Sauveterre\" de la commune de Sauveterre.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Sauveterre\" de la commune de Sauveterre.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>25 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Sauveterre\" de la commune des Sables d'Olonne.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2020-2021-2022-2023","location":{"lat":"46.49114909470038","lng":"-1.7380501593434399","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-monnet\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2020-2021-2022-2023","post_content":"<h2>Coll\u00e8ge Jean Monnet<\/h2>\n<p>Commune : Sables d'Olonne<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>26 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Sauveterre\" de la commune de Sauveterre.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Sauveterre\" de la commune de Sauveterre.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>25 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Sauveterre\" de la commune des Sables d'Olonne.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jean Monnet","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-monnet\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Jean Monnet\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Na-23_classe2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_old_slug%":"college-jean-monnet-2","%_wpgmp_metabox_latitude%":"46.49114909470038","%_wpgmp_metabox_longitude%":"-1.7380501593434399","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_23#","%_wp_page_template%":"default","%_thumbnail_id%":"11235","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7203,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"\u00eele Mouchet","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\">\u00eele Mouchet<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Ancenis-Saint Gereon \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\">\u00eele Mouchet<\/h2>\n<p>Latitude : 47.3608756\u00b0N | Longitude : 1.18575015737\u00b0W<br \/>Commune : Ancenis-Saint Gereon<\/p>\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_Na_29_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\/07\/PAL_21-22_Na_29_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\/07\/PAL_21-22_Na_29_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Ancenis-Saint Gereon \u2022 2021-2022","location":{"lat":"47.36087568333577","lng":"-1.1857501573723341","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-mouchet\/","zoom":7,"extra_fields":{"post_excerpt":"Ancenis-Saint Gereon \u2022 2021-2022","post_content":"<h2 class=\"site\">\u00eele Mouchet<\/h2>\n<p>Latitude : 47.3608756\u00b0N | Longitude : 1.18575015737\u00b0W<br \/>Commune : Ancenis-Saint Gereon<\/p>\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_Na_29_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\/07\/PAL_21-22_Na_29_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\/07\/PAL_21-22_Na_29_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"\u00eele Mouchet","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-mouchet\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.36087568333577","%_wpgmp_metabox_longitude%":"-1.1857501573723341","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_29","%_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":7212,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Fill\u00e9","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 Fill\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Fill\u00e9-sur-Sarthe \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 Fill\u00e9\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23__Na-1_Photo_Site_2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Fill\u00e9<\/h2>\n<p>Latitude : 47.897116\u00b0N | Longitude : 0.12709\u00b0E<br \/>Commune : Fill\u00e9-sur-Sarthe<\/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-Na-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\/2023\/07\/PAL-22-23-Na-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/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_Na_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_Na_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_Na_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Fill\u00e9-sur-Sarthe \u2022 2020-2021","location":{"lat":"47.897116","lng":"0.12709","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-fille\/","zoom":7,"extra_fields":{"post_excerpt":"Fill\u00e9-sur-Sarthe \u2022 2020-2021","post_content":"<h2 class=\"site\">Plage de Fill\u00e9<\/h2>\n<p>Latitude : 47.897116\u00b0N | Longitude : 0.12709\u00b0E<br \/>Commune : Fill\u00e9-sur-Sarthe<\/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-Na-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\/2023\/07\/PAL-22-23-Na-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/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_Na_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_Na_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_Na_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de Fill\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-fille\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Fill\u00e9\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23__Na-1_Photo_Site_2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.897116","%_wpgmp_metabox_longitude%":"0.12709","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_1","%_wp_page_template%":"default","%_thumbnail_id%":"11211","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":7159,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e De La Clinique Soins","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 De La Clinique Soins<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \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 De La Clinique Soins\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23__Na-1__Photo_Vrac_Macro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e De La Clinique Soins<\/h2>\n<p>Commune\u00a0: Sabl\u00e9-Sur-Sarthe<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Fill\u00e9\" de la commune de Fill\u00e9-sur-Sarthe.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-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\/2023\/07\/PAL-22-23-Na-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2022-2023","location":{"lat":"47.83891664614308","lng":"-0.34128237127804584","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-de-la-clinique-soins\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2022-2023","post_content":"<h2>Lyc\u00e9e De La Clinique Soins<\/h2>\n<p>Commune\u00a0: Sabl\u00e9-Sur-Sarthe<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Fill\u00e9\" de la commune de Fill\u00e9-sur-Sarthe.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-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\/2023\/07\/PAL-22-23-Na-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e De La Clinique Soins","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-de-la-clinique-soins\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e De La Clinique Soins\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23__Na-1__Photo_Vrac_Macro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.83891664614308","%_wpgmp_metabox_longitude%":"-0.34128237127804584","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_1#","%_wp_page_template%":"default","%_thumbnail_id%":"11210","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":8436,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Sorlock","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 Sorlock<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Mesquer \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=\"Plage de Sorlock\" width=\"300\" height=\"144\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-11-PollutionLaisse-300x144.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Sorlock<\/h2>\n<p>Latitude : 47.418376\u00b0N | Longitude : 2.469000\u00b0W<br \/>Commune : Mesquer<\/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-Na-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/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_Na_11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Mesquer \u2022 2020-2021-2022-2023","location":{"lat":"47.418376","lng":"-2.469000","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-sorlock\/","zoom":7,"extra_fields":{"post_excerpt":"Mesquer \u2022 2020-2021-2022-2023","post_content":"<h2 class=\"site\">Plage de Sorlock<\/h2>\n<p>Latitude : 47.418376\u00b0N | Longitude : 2.469000\u00b0W<br \/>Commune : Mesquer<\/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-Na-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/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_Na_11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage de Sorlock","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-sorlock\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Sorlock\" width=\"300\" height=\"144\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-11-PollutionLaisse-300x144.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.418376","%_wpgmp_metabox_longitude%":"-2.469000","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_11","%_wp_page_template%":"default","%_thumbnail_id%":"11227","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7183,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Victor Hugo","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 Victor Hugo<\/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 Victor Hugo\" width=\"300\" height=\"200\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_11-Photoclasse-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Victor Hugo<\/h2>\n<p>Commune : Nantes<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>44 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Sorlock\" de la commune de Mesquer.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>35 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Sorlock\" de la commune de Mesquer.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2020-2021-2022-2023","location":{"lat":"47.22366062493211","lng":"-1.5590303439820807","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-victor-hugo\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2020-2021-2022-2023","post_content":"<h2>Coll\u00e8ge Victor Hugo<\/h2>\n<p>Commune : Nantes<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>44 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Sorlock\" de la commune de Mesquer.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>35 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Sorlock\" de la commune de Mesquer.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Victor Hugo","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-victor-hugo\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Victor Hugo\" width=\"300\" height=\"200\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_11-Photoclasse-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.22366062493211","%_wpgmp_metabox_longitude%":"-1.5590303439820807","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_11#","%_wp_page_template%":"default","%_thumbnail_id%":"4033","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7184,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Pont L\u00e9opold-S\u00e9dar-Senghor","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\">Pont L\u00e9opold-S\u00e9dar-Senghor<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint S\u00e9bastien sur Loire \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=\"Pont L\u00e9opold-S\u00e9dar-Senghor\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_14_1_photo-_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Pont L\u00e9opold-S\u00e9dar-Senghor<\/h2>\n<p>Latitude : 47.205323\u00b0N | Longitude : 1.52308702\u00b0W<br \/>Commune : Saint S\u00e9bastien sur Loire<\/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-Na-14FM.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-Na-14FS.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_Na_14_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\/07\/PAL_21-22_Na_14_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\/07\/PAL_21-22_Na_14_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\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_Na_14_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint S\u00e9bastien sur Loire \u2022 2020-2021-2022-2023","location":{"lat":"47.20532300477635","lng":"-1.5230870246887207","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-leopold-sedar-senghor\/","zoom":7,"extra_fields":{"post_excerpt":"Saint S\u00e9bastien sur Loire \u2022 2020-2021-2022-2023","post_content":"<h2 class=\"site\">Pont L\u00e9opold-S\u00e9dar-Senghor<\/h2>\n<p>Latitude : 47.205323\u00b0N | Longitude : 1.52308702\u00b0W<br \/>Commune : Saint S\u00e9bastien sur Loire<\/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-Na-14FM.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-Na-14FS.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_Na_14_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\/07\/PAL_21-22_Na_14_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\/07\/PAL_21-22_Na_14_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\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_Na_14_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Pont L\u00e9opold-S\u00e9dar-Senghor","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-leopold-sedar-senghor\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pont L\u00e9opold-S\u00e9dar-Senghor\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_14_1_photo-_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.20532300477635","%_wpgmp_metabox_longitude%":"-1.5230870246887207","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_14","%_wp_page_template%":"default","%_thumbnail_id%":"11212","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":7187,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Montjean sur Loire","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 Montjean sur Loire<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Montjean sur Loire \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 Montjean sur Loire\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-18-photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Montjean sur Loire<\/h2>\n<p>Latitude : 47.3931024N | Longitude : 0.8703232W<br \/>Commune : Montjean sur Loire<\/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-Na-18FM.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-Na-18FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Montjean sur Loire \u2022 2022-2023","location":{"lat":"47.3931024","lng":"-0.8703232","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-montjean-sur-loire\/","zoom":7,"extra_fields":{"post_excerpt":"Montjean sur Loire \u2022 2022-2023","post_content":"<h2 class=\"site\">Berge de Montjean sur Loire<\/h2>\n<p>Latitude : 47.3931024N | Longitude : 0.8703232W<br \/>Commune : Montjean sur Loire<\/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-Na-18FM.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-Na-18FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Berge de Montjean sur Loire","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-montjean-sur-loire\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Montjean sur Loire\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-18-photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.3931024","%_wpgmp_metabox_longitude%":"-0.8703232","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_18","%_wp_page_template%":"default","%_thumbnail_id%":"11199","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":8467,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lycee Julien Gracq","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\">Lycee Julien Gracq<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \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=\"Lycee Julien Gracq\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-18-photo_groupe-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lycee Julien Gracq<\/h2>\n<p>Commune\u00a0: Beaupreau<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>70 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Montjean sur Loire\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-18FM.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-Na-18FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"2nde \u2022 2022-2023","location":{"lat":"47.192579589288115","lng":"-0.9925400560542734","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-julien-gracq\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2022-2023","post_content":"<h2>Lycee Julien Gracq<\/h2>\n<p>Commune\u00a0: Beaupreau<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>70 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Montjean sur Loire\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-18FM.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-Na-18FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Lycee Julien Gracq","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-julien-gracq\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lycee Julien Gracq\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-18-photo_groupe-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.192579589288115","%_wpgmp_metabox_longitude%":"-0.9925400560542734","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_18#","%_wp_page_template%":"default","%_thumbnail_id%":"11198","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":8468,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Route d&rsquo;Allonnes","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\">Route d&rsquo;Allonnes<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Allonnes \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=\"Route d&rsquo;Allonnes\" width=\"106\" height=\"142\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-19-Photo-sitebis-1.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Route d'Allonnes<\/h2>\n<p>Latitude : 47.973725\u00b0N | Longitude : 0.161222964\u00b0E<br \/>Commune : Allonnes<\/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-Na-19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_19_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Allonnes \u2022 2020-2021-2022-2023","location":{"lat":"47.97372557975536","lng":"0.16122296452521834","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/route-dallonnes\/","zoom":7,"extra_fields":{"post_excerpt":"Allonnes \u2022 2020-2021-2022-2023","post_content":"<h2 class=\"site\">Route d'Allonnes<\/h2>\n<p>Latitude : 47.973725\u00b0N | Longitude : 0.161222964\u00b0E<br \/>Commune : Allonnes<\/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-Na-19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_19_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Route d&rsquo;Allonnes","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/route-dallonnes\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Route d&rsquo;Allonnes\" width=\"106\" height=\"142\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-19-Photo-sitebis-1.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.97372557975536","%_wpgmp_metabox_longitude%":"0.16122296452521834","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_19","%_wp_page_template%":"default","%_thumbnail_id%":"11230","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7193,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge JF Kennedy","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 JF Kennedy<\/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 JF Kennedy\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-19-Photo-VracMacro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge JF Kennedy<\/h2>\n<p>Commune : Allonnes<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Route d'Allonnes\" de la commune d'Allonnes.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>24 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Route d'Allonnes\" de la commune d'Allonnes.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>26 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Route d'Allonnes\" de la commune d'Allonnes.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_19_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2020-2021-2022-2023","location":{"lat":"47.96545403919722","lng":"0.1621154560388231","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jf-kennedy\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2020-2021-2022-2023","post_content":"<h2>Coll\u00e8ge JF Kennedy<\/h2>\n<p>Commune : Allonnes<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Route d'Allonnes\" de la commune d'Allonnes.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>24 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Route d'Allonnes\" de la commune d'Allonnes.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>26 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Route d'Allonnes\" de la commune d'Allonnes.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_19_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge JF Kennedy","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jf-kennedy\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge JF Kennedy\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Na-19-Photo-VracMacro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.96545403919722","%_wpgmp_metabox_longitude%":"0.1621154560388231","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_19#","%_wp_page_template%":"default","%_thumbnail_id%":"11231","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7194,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Vill\u00e8s Martin","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 Vill\u00e8s Martin<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Nazaire \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=\"Plage de Vill\u00e8s Martin\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_20-Photo_Laisse-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Vill\u00e8s Martin<\/h2>\n<p>Latitude : 47.255578\u00b0N | Longitude : 2.231175\u00b0W<br \/>Commune : Saint Nazaire<\/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-Na-20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint Nazaire \u2022 2020-2021-2022-2023","location":{"lat":"47.255578","lng":"-2.231175","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-villes-martin\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Nazaire \u2022 2020-2021-2022-2023","post_content":"<h2 class=\"site\">Plage de Vill\u00e8s Martin<\/h2>\n<p>Latitude : 47.255578\u00b0N | Longitude : 2.231175\u00b0W<br \/>Commune : Saint Nazaire<\/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-Na-20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage de Vill\u00e8s Martin","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-villes-martin\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Vill\u00e8s Martin\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Na_20-Photo_Laisse-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.255578","%_wpgmp_metabox_longitude%":"-2.231175","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_20","%_wp_page_template%":"default","%_thumbnail_id%":"11238","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7197,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Fran\u00e7ois Villon","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 Villon<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                4\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 id=\"contenu_article\"><h2>Coll\u00e8ge Fran\u00e7ois Villon<\/h2>\n<p>Commune\u00a0: Les Ponts de C\u00e9 <br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>70 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin des Air\u00e9es\" de la commune des Ponts-de-C\u00e9.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-57FM.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-Na-57FS.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>70 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin des Air\u00e9es\" de la commune des Ponts-de-C\u00e9.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_57_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2021-2022-2023","location":{"lat":"47.433055230051856","lng":"-0.5219204599696762","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-francois-villon\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2021-2022-2023","post_content":"<h2>Coll\u00e8ge Fran\u00e7ois Villon<\/h2>\n<p>Commune\u00a0: Les Ponts de C\u00e9 <br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>70 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin des Air\u00e9es\" de la commune des Ponts-de-C\u00e9.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-57FM.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-Na-57FS.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>70 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin des Air\u00e9es\" de la commune des Ponts-de-C\u00e9.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_57_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Fran\u00e7ois Villon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-francois-villon\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.433055230051856","%_wpgmp_metabox_longitude%":"-0.5219204599696762","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_57#","%_wp_page_template%":"default","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":7254,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Anne De Bretagne","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 Anne De Bretagne<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\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 id=\"contenu_article\"><h2>Coll\u00e8ge Anne De Bretagne<\/h2>\n<p>Commune\u00a0: St-Herblain<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Beau rivage\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-58FM.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-Na-58FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2022-2023","location":{"lat":"47.20649747631229","lng":"-1.6566447039419423","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-anne-de-bretagne\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Anne De Bretagne<\/h2>\n<p>Commune\u00a0: St-Herblain<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Beau rivage\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-58FM.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-Na-58FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Anne De Bretagne","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-anne-de-bretagne\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.20649747631229","%_wpgmp_metabox_longitude%":"-1.6566447039419423","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_58#","%_wp_page_template%":"default","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":8538,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Alain Gerbault","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 Alain Gerbault<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\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 id=\"contenu_article\"><h2>Coll\u00e8ge Alain Gerbault<\/h2>\n<p>Commune : Laval<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>29 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Prieur\u00e9\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-8FM.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-Ren-8FS.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 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Prieur\u00e9\".\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren-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\/2022\/07\/PAL_21-22_Ren-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\/2022\/07\/PAL_21-22_Ren-8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\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_Ren_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_Ren_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_Ren_8_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>40 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"La Possonni\u00e8re\" de la commune de La Possonni\u00e8re.<\/p> \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_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\/2021\/06\/PAL_20-21_Na_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\/2021\/06\/PAL_20-21_Na_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2020-2021-2022-2023","location":{"lat":"48.06165178760043","lng":"-0.748602486358041","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-alain-gerbault\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2020-2021-2022-2023","post_content":"<h2>Coll\u00e8ge Alain Gerbault<\/h2>\n<p>Commune : Laval<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>29 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Prieur\u00e9\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-8FM.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-Ren-8FS.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 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Prieur\u00e9\".\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren-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\/2022\/07\/PAL_21-22_Ren-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\/2022\/07\/PAL_21-22_Ren-8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\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_Ren_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_Ren_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_Ren_8_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>40 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"La Possonni\u00e8re\" de la commune de La Possonni\u00e8re.<\/p> \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_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\/2021\/06\/PAL_20-21_Na_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\/2021\/06\/PAL_20-21_Na_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Alain Gerbault","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-alain-gerbault\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.06165178760043","%_wpgmp_metabox_longitude%":"-0.748602486358041","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_2#","%_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":7162,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Le Loquidy","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 Le Loquidy<\/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 id=\"contenu_article\"><h2>Coll\u00e8ge Le Loquidy<\/h2>\n<p>Commune\u00a0: Nantes<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>32 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Beau Rivage\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-34FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Beau Rivage\" de la commune de Rez\u00e9.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_34_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022-2023","location":{"lat":"47.27058072360556","lng":"-1.5457447037448928","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-le-loquidy\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022-2023","post_content":"<h2>Coll\u00e8ge Le Loquidy<\/h2>\n<p>Commune\u00a0: Nantes<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>32 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Beau Rivage\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-34FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Beau Rivage\" de la commune de Rez\u00e9.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_34_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Le Loquidy","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-le-loquidy\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.27058072360556","%_wpgmp_metabox_longitude%":"-1.5457447037448928","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_34#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7219,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Jean Mermoz","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 Jean Mermoz<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                4\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 id=\"contenu_article\"><h2>Coll\u00e8ge Jean Mermoz<\/h2>\n<p>Commune\u00a0: Nozay<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>45 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Pont Mah\u00e9\" de la commune de Penestin.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-35FM.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-Na-35FS.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>56 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Pont Mah\u00e9\" de la commune de Penestin.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_35FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2021-2022-2023","location":{"lat":"47.591847635823","lng":"-1.6279563637522088","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-mermoz\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2021-2022-2023","post_content":"<h2>Coll\u00e8ge Jean Mermoz<\/h2>\n<p>Commune\u00a0: Nozay<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>45 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Pont Mah\u00e9\" de la commune de Penestin.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-35FM.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-Na-35FS.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>56 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Pont Mah\u00e9\" de la commune de Penestin.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_35FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jean Mermoz","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-mermoz\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.591847635823","%_wpgmp_metabox_longitude%":"-1.6279563637522088","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_35#","%_wp_page_template%":"default","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":7221,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage Lancastria","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 Lancastria<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Les Moutiers en Retz \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=\"Plage Lancastria\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/Na10photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage Lancastria<\/h2>\n<p>Latitude : 47.053126\u00b0N | Longitude : 1.9971619\u00b0W<br \/>Commune : Les Moutiers en Retz<\/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-Na-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na10_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Les Moutiers en Retz \u2022 2020-2021\/2022-2023","location":{"lat":"47.053126620127934","lng":"-1.997161900633233","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-lancastria\/","zoom":7,"extra_fields":{"post_excerpt":"Les Moutiers en Retz \u2022 2020-2021\/2022-2023","post_content":"<h2 class=\"site\">Plage Lancastria<\/h2>\n<p>Latitude : 47.053126\u00b0N | Longitude : 1.9971619\u00b0W<br \/>Commune : Les Moutiers en Retz<\/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-Na-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Na_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na10_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage Lancastria","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-lancastria\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage Lancastria\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/Na10photo_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.053126620127934","%_wpgmp_metabox_longitude%":"-1.997161900633233","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_10","%_wp_page_template%":"default","%_thumbnail_id%":"4031","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2020-2021, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":7180,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro-pollution"],"%annee%":["2020-2021","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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Pont Rousseau","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 Pont Rousseau<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\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 id=\"contenu_article\"><h2>Coll\u00e8ge Pont Rousseau<\/h2>\n<p>Commune : Rez\u00e9<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>56 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Lancastria\" de la commune des Moutiers en Retz.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>29 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Lancastria\" de la commune des Moutiers en Retz.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na10_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2020-2021\/2022-2023","location":{"lat":"47.18724716362712","lng":"-1.5451937728183496","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-pont-rousseau\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2020-2021\/2022-2023","post_content":"<h2>Coll\u00e8ge Pont Rousseau<\/h2>\n<p>Commune : Rez\u00e9<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>56 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Lancastria\" de la commune des Moutiers en Retz.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>29 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Lancastria\" de la commune des Moutiers en Retz.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na10_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Pont Rousseau","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-pont-rousseau\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.18724716362712","%_wpgmp_metabox_longitude%":"-1.5451937728183496","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_10#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2020-2021, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7181,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro-pollution"],"%annee%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Salvador Allende","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 Salvador Allende<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me et 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 id=\"contenu_article\"><h2>Coll\u00e8ge Salvador Allende<\/h2>\n<p>Commune : Rez\u00e9<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>45 \u00e9l\u00e8ves de 3\u00e8me et 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont L\u00e9opold-S\u00e9dar-Senghor\" de la commune de Saint S\u00e9bastien sur Loire.\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-14FM.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-Na-14FS.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>45 \u00e9l\u00e8ves de 3\u00e8me et 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont L\u00e9opold-S\u00e9dar-Senghor\" de la commune de Saint S\u00e9bastien sur Loire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_14_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\/07\/PAL_21-22_Na_14_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\/07\/PAL_21-22_Na_14_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>24 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont L\u00e9opold-S\u00e9dar-Senghor\" de la commune de Saint S\u00e9bastien sur Loire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_14_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me et 5\u00e8me \u2022 2020-2021-2022-2023","location":{"lat":"47.18396689937043","lng":"-1.5697046151479586","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-salvador-allende\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me et 5\u00e8me \u2022 2020-2021-2022-2023","post_content":"<h2>Coll\u00e8ge Salvador Allende<\/h2>\n<p>Commune : Rez\u00e9<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>45 \u00e9l\u00e8ves de 3\u00e8me et 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont L\u00e9opold-S\u00e9dar-Senghor\" de la commune de Saint S\u00e9bastien sur Loire.\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Na-14FM.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-Na-14FS.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>45 \u00e9l\u00e8ves de 3\u00e8me et 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont L\u00e9opold-S\u00e9dar-Senghor\" de la commune de Saint S\u00e9bastien sur Loire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_14_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\/07\/PAL_21-22_Na_14_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\/07\/PAL_21-22_Na_14_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>24 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont L\u00e9opold-S\u00e9dar-Senghor\" de la commune de Saint S\u00e9bastien sur Loire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_14_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Salvador Allende","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-salvador-allende\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.18396689937043","%_wpgmp_metabox_longitude%":"-1.5697046151479586","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_14#","%_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":7188,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Wilbur Wright","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 Wilbur Wright<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                4\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 Wilbur Wright<\/h2>\n<p>Commune\u00a0: Champagn\u00e9<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Montfort le Genois\" de la commune de Montfort le Genois.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_56_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\/07\/PAL_21-22_Na_56_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\/07\/PAL_21-22_Na_56_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2021-2022","location":{"lat":"48.02280769577816","lng":"0.33168359772082157","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-wilbur-wright\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Wilbur Wright<\/h2>\n<p>Commune\u00a0: Champagn\u00e9<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Montfort le Genois\" de la commune de Montfort le Genois.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_56_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\/07\/PAL_21-22_Na_56_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\/07\/PAL_21-22_Na_56_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Wilbur Wright","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-wilbur-wright\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.02280769577816","%_wpgmp_metabox_longitude%":"0.33168359772082157","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_56#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7252,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Jacques Pr\u00e9vert","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 Jacques Pr\u00e9vert<\/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 Jacques Pr\u00e9vert<\/h2>\n<p>Commune\u00a0: Herbignac<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>56 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Pont-Mah\u00e9\" de la commune de Ass\u00e9rac.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_44FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"47.44358325711387","lng":"-2.32760682928908","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jacques-prevert-4\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Jacques Pr\u00e9vert<\/h2>\n<p>Commune\u00a0: Herbignac<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>56 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Pont-Mah\u00e9\" de la commune de Ass\u00e9rac.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_44FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jacques Pr\u00e9vert","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jacques-prevert-4\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.44358325711387","%_wpgmp_metabox_longitude%":"-2.32760682928908","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_44#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7234,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du Petit Traict (bis) (Ouest)","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 du Petit Traict (bis) (Ouest)<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Nazaire \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\">Plage du Petit Traict (bis) (Ouest)<\/h2>\n<p>Latitude : 47.26874042\u00b0N | Longitude : 2.214679375\u00b0W<br \/>Commune : Saint Nazaire<\/p>\n\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_Na_45-_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint Nazaire \u2022 2021-2022","location":{"lat":"47.268740423216194","lng":"-2.214679375714622","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-petit-traict-bis-ouest\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Nazaire \u2022 2021-2022","post_content":"<h2 class=\"site\">Plage du Petit Traict (bis) (Ouest)<\/h2>\n<p>Latitude : 47.26874042\u00b0N | Longitude : 2.214679375\u00b0W<br \/>Commune : Saint Nazaire<\/p>\n\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_Na_45-_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage du Petit Traict (bis) (Ouest)","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-petit-traict-bis-ouest\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.268740423216194","%_wpgmp_metabox_longitude%":"-2.214679375714622","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_45","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7235,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Saint Paul","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 Paul<\/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 Paul<\/h2>\n<p>Commune\u00a0: Rez\u00e9<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>110 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Petit Traict (bis) (Ouest)\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_45-_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"47.18695258178073","lng":"-1.5469128869679354","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-paul\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Saint Paul<\/h2>\n<p>Commune\u00a0: Rez\u00e9<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>110 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Petit Traict (bis) (Ouest)\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_45-_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Saint Paul","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-paul\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.18695258178073","%_wpgmp_metabox_longitude%":"-1.5469128869679354","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_45#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7236,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Estuaire du Brivais","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\">Estuaire du Brivais<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Nazaire \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\">Estuaire du Brivais<\/h2>\n<p>Latitude : 47.293730943\u00b0N | Longitude : 2.181024110\u00b0W<br \/>Commune : Saint Nazaire<\/p>\n\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_Na_48_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\/07\/PAL_21-22_Na_48_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\/07\/PAL_21-22_Na_48_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint Nazaire \u2022 2021-2022","location":{"lat":"47.29373094331242","lng":"-2.181024110101624","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/estuaire-du-brivais\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Nazaire \u2022 2021-2022","post_content":"<h2 class=\"site\">Estuaire du Brivais<\/h2>\n<p>Latitude : 47.293730943\u00b0N | Longitude : 2.181024110\u00b0W<br \/>Commune : Saint Nazaire<\/p>\n\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_Na_48_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\/07\/PAL_21-22_Na_48_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\/07\/PAL_21-22_Na_48_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Estuaire du Brivais","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/estuaire-du-brivais\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.29373094331242","%_wpgmp_metabox_longitude%":"-2.181024110101624","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_48","%_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":7241,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e professionnel des trois rivi\u00e8res","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 professionnel des trois rivi\u00e8res<\/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 professionnel des trois rivi\u00e8res<\/h2>\n<p>Commune\u00a0: Pontchateau<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>15 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Estuaire du Brivais\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_48_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\/07\/PAL_21-22_Na_48_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\/07\/PAL_21-22_Na_48_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2021-2022","location":{"lat":"47.441715949804","lng":"-2.094750004144561","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-professionnel-des-trois-rivieres\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2021-2022","post_content":"<h2>Lyc\u00e9e professionnel des trois rivi\u00e8res<\/h2>\n<p>Commune\u00a0: Pontchateau<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>15 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Estuaire du Brivais\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_48_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\/07\/PAL_21-22_Na_48_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\/07\/PAL_21-22_Na_48_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e professionnel des trois rivi\u00e8res","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-professionnel-des-trois-rivieres\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.441715949804","%_wpgmp_metabox_longitude%":"-2.094750004144561","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_48#","%_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":7242,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge d&rsquo;Or\u00e9e d&rsquo;Anjou","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 d&rsquo;Or\u00e9e d&rsquo;Anjou<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Or\u00e9e-d'Anjou \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 d'Or\u00e9e d'Anjou<\/h2>\n<p>Latitude : 47.360388\u00b0N | Longitude : 1.174882\u00b0W<br \/>Commune : Or\u00e9e-d'Anjou<\/p>\n\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_Na_51FM.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_Na_51FS.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_Na_51FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Or\u00e9e-d'Anjou \u2022 2021-2022","location":{"lat":"47.360388","lng":"-1.174882","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-doree-danjou\/","zoom":7,"extra_fields":{"post_excerpt":"Or\u00e9e-d'Anjou \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge d'Or\u00e9e d'Anjou<\/h2>\n<p>Latitude : 47.360388\u00b0N | Longitude : 1.174882\u00b0W<br \/>Commune : Or\u00e9e-d'Anjou<\/p>\n\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_Na_51FM.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_Na_51FS.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_Na_51FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge d&rsquo;Or\u00e9e d&rsquo;Anjou","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-doree-danjou\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.360388","%_wpgmp_metabox_longitude%":"-1.174882","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_51","%_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":7245,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Blaise Pascal","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 Blaise Pascal<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                1\u00e8re \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 Blaise Pascal<\/h2>\n<p>Commune\u00a0: Segr\u00e9 en Anjou Bleu<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge d'Or\u00e9e d'Anjou\" de la commune de Or\u00e9e-d'Anjou.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_51FM.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_Na_51FS.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_Na_51FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"1\u00e8re \u2022 2021-2022","location":{"lat":"47.68920457780016","lng":"-0.8778381599608415","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-blaise-pascal\/","zoom":7,"extra_fields":{"post_excerpt":"1\u00e8re \u2022 2021-2022","post_content":"<h2>Lyc\u00e9e Blaise Pascal<\/h2>\n<p>Commune\u00a0: Segr\u00e9 en Anjou Bleu<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge d'Or\u00e9e d'Anjou\" de la commune de Or\u00e9e-d'Anjou.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_51FM.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_Na_51FS.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_Na_51FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Blaise Pascal","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-blaise-pascal\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.68920457780016","%_wpgmp_metabox_longitude%":"-0.8778381599608415","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_51#","%_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":7246,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de bonne Source","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 bonne Source<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Pornichet \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\">Plage de bonne Source<\/h2>\n<p>Latitude : 47.2474854\u00b0N | Longitude : 2.325906679\u00b0W<br \/>Commune : Pornichet<\/p>\n\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_Na_53FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Pornichet \u2022 2021-2022","location":{"lat":"47.24748544198677","lng":"-2.325906679565204","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-bonne-source\/","zoom":7,"extra_fields":{"post_excerpt":"Pornichet \u2022 2021-2022","post_content":"<h2 class=\"site\">Plage de bonne Source<\/h2>\n<p>Latitude : 47.2474854\u00b0N | Longitude : 2.325906679\u00b0W<br \/>Commune : Pornichet<\/p>\n\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_Na_53FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage de bonne Source","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-bonne-source\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.24748544198677","%_wpgmp_metabox_longitude%":"-2.325906679565204","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_53","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7247,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e La Mennais","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 La Mennais<\/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 La Mennais<\/h2>\n<p>Commune\u00a0: Gu\u00e9rande<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de bonne Source\" de la commune de Pornichet.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_53FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2021-2022","location":{"lat":"47.321874993447366","lng":"-2.4320717311385023","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-la-mennais\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2021-2022","post_content":"<h2>Lyc\u00e9e La Mennais<\/h2>\n<p>Commune\u00a0: Gu\u00e9rande<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de bonne Source\" de la commune de Pornichet.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_53FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e La Mennais","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-la-mennais\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.321874993447366","%_wpgmp_metabox_longitude%":"-2.4320717311385023","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_53#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7248,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Centre Nautique Yonnais","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\">Centre Nautique Yonnais<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                La Roche-sur-Yon \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\">Centre Nautique Yonnais<\/h2>\n<p>Latitude : 46.6952349\u00b0N | Longitude : 1.41133001\u00b0W<br \/>Commune : La Roche-sur-Yon<\/p>\n\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_Na_54_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"La Roche-sur-Yon \u2022 2021-2022","location":{"lat":"46.695234947139824","lng":"-1.4113300125953085","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/centre-nautique-yonnais\/","zoom":7,"extra_fields":{"post_excerpt":"La Roche-sur-Yon \u2022 2021-2022","post_content":"<h2 class=\"site\">Centre Nautique Yonnais<\/h2>\n<p>Latitude : 46.6952349\u00b0N | Longitude : 1.41133001\u00b0W<br \/>Commune : La Roche-sur-Yon<\/p>\n\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_Na_54_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Centre Nautique Yonnais","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/centre-nautique-yonnais\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.695234947139824","%_wpgmp_metabox_longitude%":"-1.4113300125953085","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_54","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7249,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Branly","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 Branly<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\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>Lyc\u00e9e Branly<\/h2>\n<p>Commune\u00a0: La Roche sur Yon<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>48 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Centre Nautique Yonnais\" de la commune de la Roche-sur-Yon.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_54_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2021-2022","location":{"lat":"46.674474994139594","lng":"-1.4424259618408737","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-branly\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2021-2022","post_content":"<h2>Lyc\u00e9e Branly<\/h2>\n<p>Commune\u00a0: La Roche sur Yon<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>48 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Centre Nautique Yonnais\" de la commune de la Roche-sur-Yon.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_54_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Branly","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-branly\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.674474994139594","%_wpgmp_metabox_longitude%":"-1.4424259618408737","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_54#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7250,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Montfort le Genois","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 Montfort le Genois<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Montfort-le-Gesnois \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 Montfort le Genois<\/h2>\n<p>Latitude : 48.0469706\u00b0N | Longitude : 0.4186418\u00b0E<br \/>Commune : Montfort-le-Gesnois<\/p>\n\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_Na_56_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\/07\/PAL_21-22_Na_56_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\/07\/PAL_21-22_Na_56_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Montfort-le-Gesnois \u2022 2021-2022","location":{"lat":"48.0469706","lng":"0.4186418","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-montfort-le-genois\/","zoom":7,"extra_fields":{"post_excerpt":"Montfort-le-Gesnois \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Montfort le Genois<\/h2>\n<p>Latitude : 48.0469706\u00b0N | Longitude : 0.4186418\u00b0E<br \/>Commune : Montfort-le-Gesnois<\/p>\n\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_Na_56_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\/07\/PAL_21-22_Na_56_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\/07\/PAL_21-22_Na_56_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge de Montfort le Genois","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-montfort-le-genois\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.0469706","%_wpgmp_metabox_longitude%":"0.4186418","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_56","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7251,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Notre Dame de Toutes Aides","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 Notre Dame de Toutes Aides<\/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 Notre Dame de Toutes Aides<\/h2>\n<p>Commune\u00a0: Nantes<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>45 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Petit Traict (Est)\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_40_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"47.22856079313967","lng":"-1.519501902306652","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-notre-dame-de-toutes-aides\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Notre Dame de Toutes Aides<\/h2>\n<p>Commune\u00a0: Nantes<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>45 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Petit Traict (Est)\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_40_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Notre Dame de Toutes Aides","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-notre-dame-de-toutes-aides\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.22856079313967","%_wpgmp_metabox_longitude%":"-1.519501902306652","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_40#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7229,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage des Ch\u00e2telets","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 des Ch\u00e2telets<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Pr\u00e9failles \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 id=\"contenu_article\"><h2 class=\"site\">Plage des Ch\u00e2telets<\/h2>\n<p>Latitude : 47.130605\u00b0N | Longitude : 2.226145\u00b0W<br \/>Commune : Pr\u00e9failles<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>\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_Ren-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\/2022\/07\/PAL_21-22_Ren-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\/2022\/07\/PAL_21-22_Ren-8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_42FM.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_Na_42FS.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_Na_42FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Pr\u00e9failles \u2022 2021-2022-2023","location":{"lat":"47.130605","lng":"-2.226145","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-chatelets\/","zoom":7,"extra_fields":{"post_excerpt":"Pr\u00e9failles \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Plage des Ch\u00e2telets<\/h2>\n<p>Latitude : 47.130605\u00b0N | Longitude : 2.226145\u00b0W<br \/>Commune : Pr\u00e9failles<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>\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_Ren-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\/2022\/07\/PAL_21-22_Ren-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\/2022\/07\/PAL_21-22_Ren-8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_42FM.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_Na_42FS.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_Na_42FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage des Ch\u00e2telets","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-chatelets\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.130605","%_wpgmp_metabox_longitude%":"-2.226145","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_42","%_wp_page_template%":"default","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":7230,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Sacr\u00e9-Coeur La Salle","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 Sacr\u00e9-Coeur La Salle<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Terminale \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 Sacr\u00e9-Coeur La Salle<\/h2>\n<p>Commune : Angers<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de Terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Ch\u00e2telets\" de la commune de Pr\u00e9failles. Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>30 \u00e9l\u00e8ves de Terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Ch\u00e2telets\" de la commune de Pr\u00e9failles.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren-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\/2022\/07\/PAL_21-22_Ren-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\/2022\/07\/PAL_21-22_Ren-8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_42FM.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_Na_42FS.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_Na_42FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>50 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile Mureau\" de la commune de Behuard.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_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_Na_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_Na_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Terminale \u2022 2020-2021-2022-2023","location":{"lat":"47.4728632640385","lng":"-0.5561023440448571","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-sacre-coeur-la-salle\/","zoom":7,"extra_fields":{"post_excerpt":"Terminale \u2022 2020-2021-2022-2023","post_content":"<h2>Lyc\u00e9e Sacr\u00e9-Coeur La Salle<\/h2>\n<p>Commune : Angers<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de Terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Ch\u00e2telets\" de la commune de Pr\u00e9failles. Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>30 \u00e9l\u00e8ves de Terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Ch\u00e2telets\" de la commune de Pr\u00e9failles.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren-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\/2022\/07\/PAL_21-22_Ren-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\/2022\/07\/PAL_21-22_Ren-8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_42FM.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_Na_42FS.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_Na_42FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>50 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile Mureau\" de la commune de Behuard.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_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_Na_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_Na_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Sacr\u00e9-Coeur La Salle","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-sacre-coeur-la-salle\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_old_slug%":"lycee-sacre-coeur-la-salle-2","%_wpgmp_metabox_latitude%":"47.4728632640385","%_wpgmp_metabox_longitude%":"-0.5561023440448571","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_42#","%_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":8510,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Pont-Mah\u00e9","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 Pont-Mah\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Ass\u00e9rac \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\">Plage de Pont-Mah\u00e9<\/h2>\n<p>Latitude : 47.445234\u00b0N | Longitude : 2.453094\u00b0W<br \/>Commune : Ass\u00e9rac<\/p>\n\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_Na_44FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Ass\u00e9rac \u2022 2021-2022","location":{"lat":"47.445234","lng":"- 2.453094","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-pont-mahe-2\/","zoom":7,"extra_fields":{"post_excerpt":"Ass\u00e9rac \u2022 2021-2022","post_content":"<h2 class=\"site\">Plage de Pont-Mah\u00e9<\/h2>\n<p>Latitude : 47.445234\u00b0N | Longitude : 2.453094\u00b0W<br \/>Commune : Ass\u00e9rac<\/p>\n\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_Na_44FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage de Pont-Mah\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-pont-mahe-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.445234","%_wpgmp_metabox_longitude%":"- 2.453094","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_44","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7233,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Bernerie","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 Bernerie<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                La Bernerie en Retz \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 id=\"contenu_article\"><h2 class=\"site\">Plage de Bernerie<\/h2>\n<p>Latitude : 47.08083832\u00b0N | Longitude : 2.04189757\u00b0W<br \/>Commune : La Bernerie en Retz<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>\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_Na_32FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"La Bernerie en Retz \u2022 2021-2022-2023","location":{"lat":"47.0808383265101","lng":"-2.041897578293231","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-bernerie\/","zoom":7,"extra_fields":{"post_excerpt":"La Bernerie en Retz \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Plage de Bernerie<\/h2>\n<p>Latitude : 47.08083832\u00b0N | Longitude : 2.04189757\u00b0W<br \/>Commune : La Bernerie en Retz<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>\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_Na_32FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage de Bernerie","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-bernerie\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.0808383265101","%_wpgmp_metabox_longitude%":"-2.041897578293231","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_32","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7216,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Raymond Queneau","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 Raymond Queneau<\/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 Raymond Queneau<\/h2>\n<p>Commune\u00a0: Machecoul<br>Acad\u00e9mie : Nantes<\/p>\n\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 \"Plage de Bernerie\" de la commune de La Bernerie en Retz.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_32FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"46.991216090581695","lng":"-1.8193798599848694","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-raymond-queneau\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Raymond Queneau<\/h2>\n<p>Commune\u00a0: Machecoul<br>Acad\u00e9mie : Nantes<\/p>\n\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 \"Plage de Bernerie\" de la commune de La Bernerie en Retz.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_32FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Raymond Queneau","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-raymond-queneau\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.991216090581695","%_wpgmp_metabox_longitude%":"-1.8193798599848694","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_32#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7217,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Rochefort","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 Rochefort<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Rochefort \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 Rochefort<\/h2>\n<p>Latitude : 47.35944326\u00b0N | Longitude : 0.6541548838\u00b0W<br \/>Commune : Rochefort<\/p>\n\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_Na_38_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Rochefort \u2022 2021-2022","location":{"lat":"47.359443264111384","lng":"-0.6541548838485545","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-rochefort\/","zoom":7,"extra_fields":{"post_excerpt":"Rochefort \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Rochefort<\/h2>\n<p>Latitude : 47.35944326\u00b0N | Longitude : 0.6541548838\u00b0W<br \/>Commune : Rochefort<\/p>\n\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_Na_38_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Berge de Rochefort","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-rochefort\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.359443264111384","%_wpgmp_metabox_longitude%":"-0.6541548838485545","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_38","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7224,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Saint Aubin la Salle","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 Aubin la Salle<\/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 Saint Aubin la Salle<\/h2>\n<p>Commune\u00a0: Verri\u00e8res en anjou<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Rochefort\" de la commune de Rochefort.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_38_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022","location":{"lat":"47.489566775095824","lng":"-0.5027813599677404","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-aubin-la-salle\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Saint Aubin la Salle<\/h2>\n<p>Commune\u00a0: Verri\u00e8res en anjou<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Rochefort\" de la commune de Rochefort.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_38_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Saint Aubin la Salle","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-aubin-la-salle\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.489566775095824","%_wpgmp_metabox_longitude%":"-0.5027813599677404","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_38#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7225,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Institution Sainte Chr\u00e9tienne La salle","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\">Institution Sainte Chr\u00e9tienne La salle<\/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>Institution Sainte Chr\u00e9tienne La salle<\/h2>\n<p>Commune\u00a0: Sarreguemines<br>Acad\u00e9mie : Nantes<\/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 \"Plage de Vill\u00e8s Martin\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2021-2022","location":{"lat":"49.11138520054795","lng":"7.067191340306497","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/institution-sainte-chretienne-la-salle-2\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2021-2022","post_content":"<h2>Institution Sainte Chr\u00e9tienne La salle<\/h2>\n<p>Commune\u00a0: Sarreguemines<br>Acad\u00e9mie : Nantes<\/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 \"Plage de Vill\u00e8s Martin\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Institution Sainte Chr\u00e9tienne La salle","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/institution-sainte-chretienne-la-salle-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"49.11138520054795","%_wpgmp_metabox_longitude%":"7.067191340306497","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_20#","%_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":7199,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage Fort Hik\u00e9ric","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 Fort Hik\u00e9ric<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Le Croisic \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 Fort Hik\u00e9ric\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_22photo-laisse-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage Fort Hik\u00e9ric<\/h2>\n<p>Latitude : 47.291208\u00b0N | Longitude : 2.545607\u00b0W<br \/>Commune : Le Croisic<\/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_Na_22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Le Croisic \u2022 2020-2021","location":{"lat":"47.291208","lng":"-2.545607","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-fort-hikeric\/","zoom":7,"extra_fields":{"post_excerpt":"Le Croisic \u2022 2020-2021","post_content":"<h2 class=\"site\">Plage Fort Hik\u00e9ric<\/h2>\n<p>Latitude : 47.291208\u00b0N | Longitude : 2.545607\u00b0W<br \/>Commune : Le Croisic<\/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_Na_22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage Fort Hik\u00e9ric","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-fort-hikeric\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage Fort Hik\u00e9ric\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_22photo-laisse-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.291208","%_wpgmp_metabox_longitude%":"-2.545607","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_22","%_wp_page_template%":"default","%_thumbnail_id%":"4041","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7200,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Helder Camara","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 Helder Camara<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \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 id=\"contenu_article\"><h2>Coll\u00e8ge Helder Camara<\/h2>\n<p>Commune : Treilli\u00e8res<br \/>Acad\u00e9mie : Nantes<\/p>\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 \"Plage Fort Hik\u00e9ric\" de la commune du Croisic.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2020-2021","location":{"lat":"47.32544325421968","lng":"-1.6230818286383224","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-helder-camara\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2020-2021","post_content":"<h2>Coll\u00e8ge Helder Camara<\/h2>\n<p>Commune : Treilli\u00e8res<br \/>Acad\u00e9mie : Nantes<\/p>\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 \"Plage Fort Hik\u00e9ric\" de la commune du Croisic.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Helder Camara","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-helder-camara\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.32544325421968","%_wpgmp_metabox_longitude%":"-1.6230818286383224","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_22#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2020-2021"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7201,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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-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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage St-Gilles-Croix-de-Vie","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 St-Gilles-Croix-de-Vie<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                St-Gilles-Croix-de-Vie \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 class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage St-Gilles-Croix-de-Vie\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_24_photo_site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage St-Gilles-Croix-de-Vie<\/h2>\n<p>Latitude : 46.6830872\u00b0N | Longitude : 1.9325106\u00b0W<br \/>Commune : St-Gilles-Croix-de-Vie<\/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_Na_24_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_Na_24_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_Na_24_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"St-Gilles-Croix-de-Vie \u2022 2019-2020","location":{"lat":"46.6830872","lng":"-1.9325106","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-st-gilles-croix-de-vie\/","zoom":7,"extra_fields":{"post_excerpt":"St-Gilles-Croix-de-Vie \u2022 2019-2020","post_content":"<h2 class=\"site\">Plage St-Gilles-Croix-de-Vie<\/h2>\n<p>Latitude : 46.6830872\u00b0N | Longitude : 1.9325106\u00b0W<br \/>Commune : St-Gilles-Croix-de-Vie<\/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_Na_24_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_Na_24_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_Na_24_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage St-Gilles-Croix-de-Vie","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-st-gilles-croix-de-vie\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage St-Gilles-Croix-de-Vie\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_24_photo_site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.6830872","%_wpgmp_metabox_longitude%":"-1.9325106","%_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:\"22\";}","%refpoint%":"PAL_19-20_Na_24","%_wp_page_template%":"default","%_thumbnail_id%":"1609","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":7204,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Antoine de Saint-Exup\u00e9ry","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 Antoine de Saint-Exup\u00e9ry<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \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 class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Antoine de Saint-Exup\u00e9ry\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_24_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Antoine de Saint-Exup\u00e9ry<\/h2>\n<p>Commune\u00a0: Bellevigny<br \/>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>24 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage St-Gilles-Croix-de-Vie\" de la commune de St-Gilles-Croix-de-Vie.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_24_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_Na_24_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_Na_24_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2019-2020","location":{"lat":"46.783093833052725","lng":"-1.422021286391263","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-antoine-de-saint-exupery\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2019-2020","post_content":"<h2>Coll\u00e8ge Antoine de Saint-Exup\u00e9ry<\/h2>\n<p>Commune\u00a0: Bellevigny<br \/>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>24 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage St-Gilles-Croix-de-Vie\" de la commune de St-Gilles-Croix-de-Vie.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_24_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_Na_24_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_Na_24_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Antoine de Saint-Exup\u00e9ry","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-antoine-de-saint-exupery\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Antoine de Saint-Exup\u00e9ry\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_24_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.783093833052725","%_wpgmp_metabox_longitude%":"-1.422021286391263","%_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:\"22\";}","%refpoint%":"PAL_19-20_Na_24#","%_wp_page_template%":"default","%_thumbnail_id%":"1608","taxonomy=type-site-classe":"Classes","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-classe.png"},"id":7205,"custom_filters":{"%type-site-classe%":["Classes"],"%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-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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de l&rsquo;avant port","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;avant port<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Nazaire \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=\"Plage de l&rsquo;avant port\" width=\"300\" height=\"162\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_25Site-300x162.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de l'avant port<\/h2>\n<p>Latitude : 47.270389\u00b0N | Longitude : 2.203817\u00b0W<br \/>Commune : Saint Nazaire<\/p>\n\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_Na_25FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_25FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint Nazaire \u2022 2020-2021-2022","location":{"lat":"47.270389","lng":"-2.203817","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-lavant-port\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Nazaire \u2022 2020-2021-2022","post_content":"<h2 class=\"site\">Plage de l'avant port<\/h2>\n<p>Latitude : 47.270389\u00b0N | Longitude : 2.203817\u00b0W<br \/>Commune : Saint Nazaire<\/p>\n\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_Na_25FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_25FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage de l&rsquo;avant port","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-lavant-port\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de l&rsquo;avant port\" width=\"300\" height=\"162\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_25Site-300x162.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.270389","%_wpgmp_metabox_longitude%":"-2.203817","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_25","%_wp_page_template%":"default","%_thumbnail_id%":"4043","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7206,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Sainte Philom\u00e8ne","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 Sainte Philom\u00e8ne<\/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>Coll\u00e8ge Sainte Philom\u00e8ne<\/h2>\n<p>Commune\u00a0: Cou\u00ebron<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de l'avant port\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_25FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2021-2022","location":{"lat":"47.223668600593214","lng":"-1.7224219276756454","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-sainte-philomene\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Sainte Philom\u00e8ne<\/h2>\n<p>Commune\u00a0: Cou\u00ebron<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de l'avant port\" de la commune de Saint Nazaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_25FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Sainte Philom\u00e8ne","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-sainte-philomene\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.223668600593214","%_wpgmp_metabox_longitude%":"-1.7224219276756454","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_25#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7207,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du vieux m\u00f4le","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 du vieux m\u00f4le<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Nazaire \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 du vieux m\u00f4le\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na-plage-vieux-mole-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage du vieux m\u00f4le<\/h2>\n<p>Latitude : 47.271692\u00b0N | Longitude : 2.198314\u00b0W<br \/>Commune : Saint Nazaire<\/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_Na_26FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint Nazaire \u2022 2020-2021","location":{"lat":"47.271692","lng":"-2.198314","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-vieux-mole\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Nazaire \u2022 2020-2021","post_content":"<h2 class=\"site\">Plage du vieux m\u00f4le<\/h2>\n<p>Latitude : 47.271692\u00b0N | Longitude : 2.198314\u00b0W<br \/>Commune : Saint Nazaire<\/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_Na_26FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage du vieux m\u00f4le","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-vieux-mole\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage du vieux m\u00f4le\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na-plage-vieux-mole-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.271692","%_wpgmp_metabox_longitude%":"-2.198314","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_26","%_wp_page_template%":"default","%_thumbnail_id%":"4044","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7208,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Corsept","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 Corsept<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Corsept \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\">Plage de Corsept<\/h2>\n<p>Latitude : 47.2880147\u00b0N | Longitude : 2.0461137421\u00b0W<br \/>Commune : Corsept<\/p>\n\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_Na_27_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\/07\/PAL_21_22_Na_27_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\/07\/PAL_21_22_Na_27_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Corsept \u2022 2021-2022","location":{"lat":"47.2880147809101","lng":"-2.046113742118154","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-corsept\/","zoom":7,"extra_fields":{"post_excerpt":"Corsept \u2022 2021-2022","post_content":"<h2 class=\"site\">Plage de Corsept<\/h2>\n<p>Latitude : 47.2880147\u00b0N | Longitude : 2.0461137421\u00b0W<br \/>Commune : Corsept<\/p>\n\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_Na_27_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\/07\/PAL_21_22_Na_27_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\/07\/PAL_21_22_Na_27_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de Corsept","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-corsept\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.2880147809101","%_wpgmp_metabox_longitude%":"-2.046113742118154","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_27","%_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":7209,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Louise Michel","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 Louise Michel<\/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 Louise Michel<\/h2>\n<p>Commune\u00a0: Paimboeuf<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>120 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Corsept\" de la commune de Corsept.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21_22_Na_27_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\/07\/PAL_21_22_Na_27_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\/07\/PAL_21_22_Na_27_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"47.28659437731933","lng":"-2.024955744634595","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-louise-michel-2\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Louise Michel<\/h2>\n<p>Commune\u00a0: Paimboeuf<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>120 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Corsept\" de la commune de Corsept.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21_22_Na_27_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\/07\/PAL_21_22_Na_27_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\/07\/PAL_21_22_Na_27_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Louise Michel","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-louise-michel-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.28659437731933","%_wpgmp_metabox_longitude%":"-2.024955744634595","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_27#","%_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":7210,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de la Braie","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 la Braie<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Notre Dame de Monts \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\">Plage de la Braie<\/h2>\n<p>Latitude : 46.841576696\u00b0N | Longitude : 2.1463330543\u00b0W<br \/>Commune : Notre Dame de Monts<\/p>\n\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_Na_28_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\/07\/PAL_21-22_Na_28_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\/07\/PAL_21-22_Na_28_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Notre Dame de Monts \u2022 2021-2022","location":{"lat":"46.841576696372535","lng":"-2.1463330543475037","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-la-braie\/","zoom":7,"extra_fields":{"post_excerpt":"Notre Dame de Monts \u2022 2021-2022","post_content":"<h2 class=\"site\">Plage de la Braie<\/h2>\n<p>Latitude : 46.841576696\u00b0N | Longitude : 2.1463330543\u00b0W<br \/>Commune : Notre Dame de Monts<\/p>\n\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_Na_28_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\/07\/PAL_21-22_Na_28_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\/07\/PAL_21-22_Na_28_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de la Braie","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-la-braie\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.841576696372535","%_wpgmp_metabox_longitude%":"-2.1463330543475037","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_28","%_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":7211,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Saint Benoit","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 Benoit<\/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 Benoit<\/h2>\n<p>Commune\u00a0: Or\u00e9e d'Anjou<br>Acad\u00e9mie : Nantes<\/p>\n\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 \"\u00eele Mouchet\" de la commune de Ancenis-Saint Gereon.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_29_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\/07\/PAL_21-22_Na_29_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\/07\/PAL_21-22_Na_29_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"47.33623778046958","lng":"-1.2677812170626201","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-benoit\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Saint Benoit<\/h2>\n<p>Commune\u00a0: Or\u00e9e d'Anjou<br>Acad\u00e9mie : Nantes<\/p>\n\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 \"\u00eele Mouchet\" de la commune de Ancenis-Saint Gereon.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_29_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\/07\/PAL_21-22_Na_29_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\/07\/PAL_21-22_Na_29_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Saint Benoit","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-benoit\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.33623778046958","%_wpgmp_metabox_longitude%":"-1.2677812170626201","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_29#","%_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":7213,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Aristide Briand","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 Aristide Briand<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \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 id=\"contenu_article\"><h2>Lyc\u00e9e Aristide Briand<\/h2>\n<p>Commune : Saint Nazaire<br \/>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>95 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Vill\u00e8s Martin\" (2nde 10) de la commune de Saint Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<p>L'\u00e9tude porte sur le site \"Plage de l'avant port\" (2nde 17 groupe 2) de la commune de Saint Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_25FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n <p> L'\u00e9tude porte sur le site \"Plage du vieux m\u00f4le\" (2nde 17 groupe 1) de la commune de Saint Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_26FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2020-2021","location":{"lat":"47.274282146831375","lng":"-2.2313151709692676","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-aristide-briand\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2020-2021","post_content":"<h2>Lyc\u00e9e Aristide Briand<\/h2>\n<p>Commune : Saint Nazaire<br \/>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>95 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Vill\u00e8s Martin\" (2nde 10) de la commune de Saint Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<p>L'\u00e9tude porte sur le site \"Plage de l'avant port\" (2nde 17 groupe 2) de la commune de Saint Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_25FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n <p> L'\u00e9tude porte sur le site \"Plage du vieux m\u00f4le\" (2nde 17 groupe 1) de la commune de Saint Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_26FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Aristide Briand","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-aristide-briand\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.274282146831375","%_wpgmp_metabox_longitude%":"-2.2313151709692676","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_20#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2020-2021"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7198,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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-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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Olympe de Gouges","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 Olympe de Gouges<\/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 Olympe de Gouges<\/h2>\n\n<p>Commune\u00a0: Sainte-Pazanne<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>26 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Lancastria\" de la commune des Moutiers en Retz.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022","location":{"lat":"47.0970175940862","lng":"-1.8163953557499637","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-olympe-de-gouges-2\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Olympe de Gouges<\/h2>\n\n<p>Commune\u00a0: Sainte-Pazanne<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>26 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Lancastria\" de la commune des Moutiers en Retz.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Olympe de Gouges","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-olympe-de-gouges-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.0970175940862","%_wpgmp_metabox_longitude%":"-1.8163953557499637","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_10#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7182,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Les Demoiselles","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\">Les Demoiselles<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                P\u00e9nestin \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=\"Les Demoiselles\" width=\"173\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_12-Photo_Site-173x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Les Demoiselles<\/h2>\n<p>Latitude : 47.47371\u00b0N | Longitude : 2.48906928\u00b0W<br \/>Commune : P\u00e9nestin<\/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_Na_12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"P\u00e9nestin \u2022 2020-2021","location":{"lat":"47.47371898511847","lng":"-2.4890692874023346","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/les-demoiselles\/","zoom":7,"extra_fields":{"post_excerpt":"P\u00e9nestin \u2022 2020-2021","post_content":"<h2 class=\"site\">Les Demoiselles<\/h2>\n<p>Latitude : 47.47371\u00b0N | Longitude : 2.48906928\u00b0W<br \/>Commune : P\u00e9nestin<\/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_Na_12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Les Demoiselles","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/les-demoiselles\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Les Demoiselles\" width=\"173\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_12-Photo_Site-173x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.47371898511847","%_wpgmp_metabox_longitude%":"-2.4890692874023346","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_12","%_wp_page_template%":"default","%_thumbnail_id%":"4034","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7185,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Grand Air","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 Grand Air<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \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 id=\"contenu_article\"><h2>Coll\u00e8ge Grand Air<\/h2>\n<p>Commune : La Baule-Escoublac<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>150 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Les Demoiselles\" de la commune de P\u00e9nestin.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2020-2021","location":{"lat":"47.28735145382591","lng":"-2.3762439728155393","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-grand-air\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2020-2021","post_content":"<h2>Coll\u00e8ge Grand Air<\/h2>\n<p>Commune : La Baule-Escoublac<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>150 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Les Demoiselles\" de la commune de P\u00e9nestin.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Grand Air","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-grand-air\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.28735145382591","%_wpgmp_metabox_longitude%":"-2.3762439728155393","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_12#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2020-2021"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7186,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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-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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Fert\u00e9-Bernard","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\">Fert\u00e9-Bernard<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Fert\u00e9-Bernard \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 id=\"contenu_article\"><h2 class=\"site\">Fert\u00e9-Bernard<\/h2>\n<p>Latitude : 48.190106\u00b0N | Longitude : 0.651323\u00b0E<br \/>Commune : Fert\u00e9-Bernard<\/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_Na_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Fert\u00e9-Bernard \u2022 2020-2021","location":{"lat":"48.190106","lng":"0.651323","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ferte-bernard\/","zoom":7,"extra_fields":{"post_excerpt":"Fert\u00e9-Bernard \u2022 2020-2021","post_content":"<h2 class=\"site\">Fert\u00e9-Bernard<\/h2>\n<p>Latitude : 48.190106\u00b0N | Longitude : 0.651323\u00b0E<br \/>Commune : Fert\u00e9-Bernard<\/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_Na_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Fert\u00e9-Bernard","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ferte-bernard\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.190106","%_wpgmp_metabox_longitude%":"0.651323","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_16","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7189,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Georges Lambert","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 Lambert<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me \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 id=\"contenu_article\"><h2>Coll\u00e8ge Georges Lambert<\/h2>\n<p>Commune : La Fert\u00e9-Bernard<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Fert\u00e9-Bernard\" de la commune de Fert\u00e9-Bernard.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2020-2021","location":{"lat":"48.190523045929005","lng":"0.6529576902424414","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-georges-lambert\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2020-2021","post_content":"<h2>Coll\u00e8ge Georges Lambert<\/h2>\n<p>Commune : La Fert\u00e9-Bernard<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Fert\u00e9-Bernard\" de la commune de Fert\u00e9-Bernard.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Georges Lambert","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-georges-lambert\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.190523045929005","%_wpgmp_metabox_longitude%":"0.6529576902424414","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_16#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2020-2021"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7190,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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-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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Pont du Gu\u00e9 Bernisson","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\">Pont du Gu\u00e9 Bernisson<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Le Mans \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=\"Pont du Gu\u00e9 Bernisson\" width=\"300\" height=\"165\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_17Site-300x165.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Pont du Gu\u00e9 Bernisson<\/h2>\n<p>Latitude : 47.99106\u00b0N | Longitude : 0.238557\u00b0E<br \/>Commune : Le Mans<\/p>\n\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_Na_17FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_17_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Le Mans \u2022 2020-2021-2022","location":{"lat":"47.99106","lng":"0.238557","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-du-gue-bernisson\/","zoom":7,"extra_fields":{"post_excerpt":"Le Mans \u2022 2020-2021-2022","post_content":"<h2 class=\"site\">Pont du Gu\u00e9 Bernisson<\/h2>\n<p>Latitude : 47.99106\u00b0N | Longitude : 0.238557\u00b0E<br \/>Commune : Le Mans<\/p>\n\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_Na_17FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_17_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Pont du Gu\u00e9 Bernisson","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-du-gue-bernisson\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pont du Gu\u00e9 Bernisson\" width=\"300\" height=\"165\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_17Site-300x165.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.99106","%_wpgmp_metabox_longitude%":"0.238557","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_17","%_wp_page_template%":"default","%_thumbnail_id%":"4037","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7191,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Costa Gavras","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 Costa Gavras<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\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 Costa Gavras<\/h2>\n<p>Commune : Le Mans<br \/>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont du Gu\u00e9 Bernisson\" de la commune du Mans.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_17FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>20 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont du Gu\u00e9 Bernisson\" de la commune du Mans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_17_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2020-2021-2022","location":{"lat":"47.99401175655129","lng":"0.23212058487485543","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-costa-gavras\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2020-2021-2022","post_content":"<h2>Coll\u00e8ge Costa Gavras<\/h2>\n<p>Commune : Le Mans<br \/>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont du Gu\u00e9 Bernisson\" de la commune du Mans.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_17FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>20 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont du Gu\u00e9 Bernisson\" de la commune du Mans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_17_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Costa Gavras","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-costa-gavras\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.99401175655129","%_wpgmp_metabox_longitude%":"0.23212058487485543","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_17#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7192,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de la Davi\u00e8re","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 la Davi\u00e8re<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint jean de Mont \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 la Davi\u00e8re\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_21-Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de la Davi\u00e8re<\/h2>\n<p>Latitude : 46.7983122\u00b0N | Longitude : 2.1093629\u00b0W<br \/>Commune : Saint jean de Mont<\/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_Na_21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint jean de Mont \u2022 2020-2021","location":{"lat":"46.7983122","lng":"-2.1093629","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-la-daviere\/","zoom":7,"extra_fields":{"post_excerpt":"Saint jean de Mont \u2022 2020-2021","post_content":"<h2 class=\"site\">Plage de la Davi\u00e8re<\/h2>\n<p>Latitude : 46.7983122\u00b0N | Longitude : 2.1093629\u00b0W<br \/>Commune : Saint jean de Mont<\/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_Na_21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage de la Davi\u00e8re","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-la-daviere\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de la Davi\u00e8re\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_21-Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.7983122","%_wpgmp_metabox_longitude%":"-2.1093629","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_21","%_wp_page_template%":"default","%_thumbnail_id%":"4040","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":7195,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Saint Joseph","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 Joseph<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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 Saint Joseph<\/h2>\n<p>Commune : Challans<br \/>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de la Braie\" de la commune de Notre Dame de Monts.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_28_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\/07\/PAL_21-22_Na_28_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\/07\/PAL_21-22_Na_28_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>26 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"plage de la Davi\u00e8re\" de la commune de Saint jean de Mont.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_21FM.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_Na_21_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2020-2021-2022","location":{"lat":"46.83946748289104","lng":"-1.8634031079445887","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-joseph\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2020-2021-2022","post_content":"<h2>Coll\u00e8ge Saint Joseph<\/h2>\n<p>Commune : Challans<br \/>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de la Braie\" de la commune de Notre Dame de Monts.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_28_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\/07\/PAL_21-22_Na_28_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\/07\/PAL_21-22_Na_28_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>26 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"plage de la Davi\u00e8re\" de la commune de Saint jean de Mont.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_21FM.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_Na_21_D.xlsx\" target=\"_blank\">Synth\u00e8se des observations<\/a> (tableur)<\/li>\n<\/ul>","post_title":"Coll\u00e8ge Saint Joseph","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-joseph\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.83946748289104","%_wpgmp_metabox_longitude%":"-1.8634031079445887","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_21#","%_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":7196,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Porc\u00e9","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 Porc\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint-Nazaire \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 id=\"contenu_article\"><h2 class=\"site\">Plage de Porc\u00e9<\/h2>\n<p>Latitude : 47.370982\u00b0N | Longitude : 2.2532082\u00b0W<br \/>Commune : Saint-Nazaire\/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_Na_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_Na_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_Na_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint-Nazaire \u2022 2020-2021","location":{"lat":"47.2533254","lng":"-2.2532082","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-porce\/","zoom":7,"extra_fields":{"post_excerpt":"Saint-Nazaire \u2022 2020-2021","post_content":"<h2 class=\"site\">Plage de Porc\u00e9<\/h2>\n<p>Latitude : 47.370982\u00b0N | Longitude : 2.2532082\u00b0W<br \/>Commune : Saint-Nazaire\/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_Na_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_Na_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_Na_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de Porc\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-porce\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.2533254","%_wpgmp_metabox_longitude%":"-2.2532082","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_7","%_wp_page_template%":"default","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":7174,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e des m\u00e9tiers Heinlex","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 des m\u00e9tiers Heinlex<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde Pro \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 id=\"contenu_article\"><h2>Lyc\u00e9e des m\u00e9tiers Heinlex<\/h2>\n<p>Commune : Saint-Nazaire<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>24 \u00e9l\u00e8ves de 2nde Pro<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porc\u00e9\" de la commune de Saint-Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_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_Na_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_Na_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde Pro \u2022 2020-2021","location":{"lat":"47.263936949140216","lng":"-2.262781057543144","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-des-metiers-heinlex\/","zoom":7,"extra_fields":{"post_excerpt":"2nde Pro \u2022 2020-2021","post_content":"<h2>Lyc\u00e9e des m\u00e9tiers Heinlex<\/h2>\n<p>Commune : Saint-Nazaire<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>24 \u00e9l\u00e8ves de 2nde Pro<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porc\u00e9\" de la commune de Saint-Nazaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_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_Na_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_Na_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e des m\u00e9tiers Heinlex","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-des-metiers-heinlex\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.263936949140216","%_wpgmp_metabox_longitude%":"-2.262781057543144","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_7#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","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-classe.png"},"id":7175,"custom_filters":{"%type-site-classe%":["Classes"],"%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-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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Maison de l&rsquo;eau","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\">Maison de l&rsquo;eau<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Le Mans \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=\"Maison de l&rsquo;eau\" width=\"300\" height=\"135\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_8_Photo_Site-300x135.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Maison de l'eau<\/h2>\n<p>Latitude : 47.994332\u00b0N | Longitude : 0.237250\u00b0E<br \/>Commune : Le Mans\/p>\n\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_Na_8FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_8FM.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_Na_8FS.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_Na_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Le Mans \u2022 2020-2021-2022","location":{"lat":"47.994332","lng":"0.237250","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/maison-de-leau\/","zoom":7,"extra_fields":{"post_excerpt":"Le Mans \u2022 2020-2021-2022","post_content":"<h2 class=\"site\">Maison de l'eau<\/h2>\n<p>Latitude : 47.994332\u00b0N | Longitude : 0.237250\u00b0E<br \/>Commune : Le Mans\/p>\n\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_Na_8FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_8FM.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_Na_8FS.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_Na_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Maison de l&rsquo;eau","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/maison-de-leau\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Maison de l&rsquo;eau\" width=\"300\" height=\"135\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_8_Photo_Site-300x135.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.994332","%_wpgmp_metabox_longitude%":"0.237250","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_8","%_wp_page_template%":"default","%_thumbnail_id%":"4002","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":7176,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Le Mans Sud","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 Le Mans Sud<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \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 id=\"contenu_article\"><h2>Lyc\u00e9e Le Mans Sud<\/h2>\n<p>Commune : Le Mans<br \/>Acad\u00e9mie : Nantes<\/p>\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 \"Maison de l'eau\" de la commune de Le Mans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_8FM.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_Na_8FS.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_Na_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2020-2021","location":{"lat":"47.98192732041002","lng":"0.22873798480417534","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-le-mans-sud\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2020-2021","post_content":"<h2>Lyc\u00e9e Le Mans Sud<\/h2>\n<p>Commune : Le Mans<br \/>Acad\u00e9mie : Nantes<\/p>\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 \"Maison de l'eau\" de la commune de Le Mans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_8FM.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_Na_8FS.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_Na_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Le Mans Sud","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-le-mans-sud\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.98192732041002","%_wpgmp_metabox_longitude%":"0.22873798480417534","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_8#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","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-classe.png"},"id":7177,"custom_filters":{"%type-site-classe%":["Classes"],"%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-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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Banc de Sable Saumur","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\">Banc de Sable Saumur<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saumur \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=\"Banc de Sable Saumur\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20_21_Na_9-Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Banc de Sable Saumur<\/h2>\n<p>Latitude : 48.935788\u00b0N | Longitude : 6.059511\u00b0E<br \/>Commune : Saumur<\/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_Na_9_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saumur \u2022 2020-2021","location":{"lat":"47.269214","lng":"-0.089634","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/banc-de-sable-saumur\/","zoom":7,"extra_fields":{"post_excerpt":"Saumur \u2022 2020-2021","post_content":"<h2 class=\"site\">Banc de Sable Saumur<\/h2>\n<p>Latitude : 48.935788\u00b0N | Longitude : 6.059511\u00b0E<br \/>Commune : Saumur<\/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_Na_9_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Banc de Sable Saumur","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/banc-de-sable-saumur\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Banc de Sable Saumur\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20_21_Na_9-Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.269214","%_wpgmp_metabox_longitude%":"-0.089634","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_9","%_wp_page_template%":"default","%_thumbnail_id%":"4029","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":7178,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Saint-Louis","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-Louis<\/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 Saint-Louis\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20_21_Na_9-Photo_Classe-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Saint-Louis<\/h2>\n<p>Commune : Saumur<br \/>Acad\u00e9mie : Nantes<\/p>\n\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 \"Maison de l'eau\" de la commune de Le Mans.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_8FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n\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 \"Banc de Sable Saumur\" de la commune de Saumur.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_9_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2020-2021-2022","location":{"lat":"47.258550110683686","lng":"-0.0848066458277486","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-louis\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2020-2021-2022","post_content":"<h2>Coll\u00e8ge Saint-Louis<\/h2>\n<p>Commune : Saumur<br \/>Acad\u00e9mie : Nantes<\/p>\n\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 \"Maison de l'eau\" de la commune de Le Mans.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_8FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n\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 \"Banc de Sable Saumur\" de la commune de Saumur.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_9_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Saint-Louis","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-louis\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Saint-Louis\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20_21_Na_9-Photo_Classe-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.258550110683686","%_wpgmp_metabox_longitude%":"-0.0848066458277486","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_9#","%_wp_page_template%":"default","%_thumbnail_id%":"4030","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7179,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Pierre Belon","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 Pierre Belon<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me \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 id=\"contenu_article\"><h2>Coll\u00e8ge Pierre Belon<\/h2>\n<p>Commune : C\u00e9rans-Foulletourte<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>15 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Fill\u00e9\" de la commune de Fill\u00e9-sur-Sarthe.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_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_Na_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_Na_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2020-2021","location":{"lat":"47.828672329794436","lng":"0.08139938295026254","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-pierre-belon\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2020-2021","post_content":"<h2>Coll\u00e8ge Pierre Belon<\/h2>\n<p>Commune : C\u00e9rans-Foulletourte<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>15 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Fill\u00e9\" de la commune de Fill\u00e9-sur-Sarthe.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_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_Na_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_Na_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Pierre Belon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-pierre-belon\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.828672329794436","%_wpgmp_metabox_longitude%":"0.08139938295026254","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_1#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","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-classe.png"},"id":7160,"custom_filters":{"%type-site-classe%":["Classes"],"%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-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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"La Possonni\u00e8re","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\">La Possonni\u00e8re<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                La Possonni\u00e8re \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=\"La Possonni\u00e8re\" width=\"300\" height=\"178\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_2-Photo_Site2-300x178.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">La Possonni\u00e8re<\/h2>\n<p>Latitude : 47.3702778\u00b0N | Longitude : 0.6833333\u00b0W<br \/>Commune : La Possonni\u00e8re\/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_Na_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\/2021\/06\/PAL_20-21_Na_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\/2021\/06\/PAL_20-21_Na_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"La Possonni\u00e8re \u2022 2020-2021","location":{"lat":"47.3702778","lng":"-0.6833333333333333","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/la-possonniere\/","zoom":7,"extra_fields":{"post_excerpt":"La Possonni\u00e8re \u2022 2020-2021","post_content":"<h2 class=\"site\">La Possonni\u00e8re<\/h2>\n<p>Latitude : 47.3702778\u00b0N | Longitude : 0.6833333\u00b0W<br \/>Commune : La Possonni\u00e8re\/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_Na_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\/2021\/06\/PAL_20-21_Na_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\/2021\/06\/PAL_20-21_Na_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"La Possonni\u00e8re","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/la-possonniere\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"La Possonni\u00e8re\" width=\"300\" height=\"178\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_2-Photo_Site2-300x178.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.3702778","%_wpgmp_metabox_longitude%":"-0.6833333333333333","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_2","%_wp_page_template%":"default","%_thumbnail_id%":"3998","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":7161,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage Valentin","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 Valentin<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Batz-sur-Mer \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 Valentin\" width=\"300\" height=\"172\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_3_Photo_Laisse-300x172.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage Valentin<\/h2>\n<p>Latitude : 47.277559\u00b0N | Longitude : 2.493839\u00b0W<br \/>Commune : Batz-sur-Mer\/p>\n\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_2021_Na_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_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_Na_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_Na_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Batz-sur-Mer \u2022 2020-2021","location":{"lat":"47.277559","lng":"-2.493839","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-valentin\/","zoom":7,"extra_fields":{"post_excerpt":"Batz-sur-Mer \u2022 2020-2021","post_content":"<h2 class=\"site\">Plage Valentin<\/h2>\n<p>Latitude : 47.277559\u00b0N | Longitude : 2.493839\u00b0W<br \/>Commune : Batz-sur-Mer\/p>\n\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_2021_Na_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_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_Na_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_Na_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage Valentin","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-valentin\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage Valentin\" width=\"300\" height=\"172\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_3_Photo_Laisse-300x172.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.277559","%_wpgmp_metabox_longitude%":"-2.493839","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_3","%_wp_page_template%":"default","%_thumbnail_id%":"3999","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":7163,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Mona Ozouf","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 Mona Ozouf<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                4\u00e8me \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 id=\"contenu_article\"><h2>Coll\u00e8ge Mona Ozouf<\/h2>\n<p>Commune : Savenay<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>28 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Batz-sur-Mer\" de la commune de La Possonni\u00e8re.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_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_Na_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_Na_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2020-2021","location":{"lat":"47.36716287824787","lng":"-1.9282408882260862","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-mona-ozouf\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2020-2021","post_content":"<h2>Coll\u00e8ge Mona Ozouf<\/h2>\n<p>Commune : Savenay<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>28 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Batz-sur-Mer\" de la commune de La Possonni\u00e8re.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_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_Na_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_Na_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Mona Ozouf","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-mona-ozouf\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.36716287824787","%_wpgmp_metabox_longitude%":"-1.9282408882260862","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_3#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","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-classe.png"},"id":7164,"custom_filters":{"%type-site-classe%":["Classes"],"%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-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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"College Marcelle Baron","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\">College Marcelle Baron<\/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>College Marcelle Baron<\/h2>\n<p>Commune\u00a0: Heric<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>160 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Valentin\" de la commune de Batz-sur-Mer.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_2021_Na_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"47.40747416573676","lng":"-1.6488635380599879","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-marcelle-baron\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>College Marcelle Baron<\/h2>\n<p>Commune\u00a0: Heric<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>160 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Valentin\" de la commune de Batz-sur-Mer.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_2021_Na_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"College Marcelle Baron","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-marcelle-baron\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.40747416573676","%_wpgmp_metabox_longitude%":"-1.6488635380599879","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_3#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7165,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage des Sableaux","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 des Sableaux<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Noirmoutier en l'\u00eele \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=\"Plage des Sableaux\" width=\"300\" height=\"175\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_4-photo_Site-300x175.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage des Sableaux<\/h2>\n<p>Latitude : 46.996490\u00b0N | Longitude : 2.21866512\u00b0W<br \/>Commune : Noirmoutier en l'\u00eele\/p>\n\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_Na_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_4FM.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_Na_4FS.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_Na_4FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n\n<\/ul><\/div><\/div>","content":"Noirmoutier en l'\u00eele \u2022 2020-2021-2022","location":{"lat":"46.996490478515625","lng":"-2.21866512298584","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-sableaux\/","zoom":7,"extra_fields":{"post_excerpt":"Noirmoutier en l'\u00eele \u2022 2020-2021-2022","post_content":"<h2 class=\"site\">Plage des Sableaux<\/h2>\n<p>Latitude : 46.996490\u00b0N | Longitude : 2.21866512\u00b0W<br \/>Commune : Noirmoutier en l'\u00eele\/p>\n\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_Na_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\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_Na_4FM.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_Na_4FS.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_Na_4FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n\n<\/ul>","post_title":"Plage des Sableaux","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-sableaux\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage des Sableaux\" width=\"300\" height=\"175\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_4-photo_Site-300x175.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.996490478515625","%_wpgmp_metabox_longitude%":"-2.21866512298584","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_4","%_wp_page_template%":"default","%_thumbnail_id%":"4000","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":7166,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Moli\u00e8re","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 Moli\u00e8re<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                4\u00e8me \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 id=\"contenu_article\"><h2>Coll\u00e8ge Moli\u00e8re<\/h2>\n<p>Commune : Noirmoutier en l'\u00eele<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>26 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Sableaux\" de la commune de Noirmoutier en l'\u00eele.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_4FM.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_Na_4FS.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_Na_4FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2020-2021","location":{"lat":"47.002168","lng":"-2.238258","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-moliere\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2020-2021","post_content":"<h2>Coll\u00e8ge Moli\u00e8re<\/h2>\n<p>Commune : Noirmoutier en l'\u00eele<br \/>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>26 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Sableaux\" de la commune de Noirmoutier en l'\u00eele.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_4FM.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_Na_4FS.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_Na_4FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Moli\u00e8re","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-moliere\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.002168","%_wpgmp_metabox_longitude%":"-2.238258","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_4#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","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-classe.png"},"id":7167,"custom_filters":{"%type-site-classe%":["Classes"],"%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-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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lycee Aime Cesaire","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\">Lycee Aime Cesaire<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Terminale \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>Lycee Aime Cesaire<\/h2>\n<p>Commune\u00a0: Clisson<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de Terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Veillon\" de la commune Talmont Saint-Hilaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Terminale \u2022 2021-2022","location":{"lat":"46.5577997575964","lng":"-1.0541056999597718","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-aime-cesaire\/","zoom":7,"extra_fields":{"post_excerpt":"Terminale \u2022 2021-2022","post_content":"<h2>Lycee Aime Cesaire<\/h2>\n<p>Commune\u00a0: Clisson<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de Terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Veillon\" de la commune Talmont Saint-Hilaire.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Na_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Lycee Aime Cesaire","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-aime-cesaire\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.5577997575964","%_wpgmp_metabox_longitude%":"-1.0541056999597718","%_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:\"22\";}","%refpoint%":"PAL_21-22_Na_4#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"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":7168,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Ile Mureau","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 Mureau<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Behuard \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=\"Ile Mureau\" width=\"300\" height=\"175\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_5-Site-de-collecte-laisse-Nord-300x175.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Ile Mureau<\/h2>\n<p>Latitude : 47.370982\u00b0N | Longitude : 0.675120\u00b0W<br \/>Commune : Behuard\/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_Na_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_Na_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_Na_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Behuard \u2022 2020-2021","location":{"lat":"47.370982","lng":"-0.675120","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-mureau\/","zoom":7,"extra_fields":{"post_excerpt":"Behuard \u2022 2020-2021","post_content":"<h2 class=\"site\">Ile Mureau<\/h2>\n<p>Latitude : 47.370982\u00b0N | Longitude : 0.675120\u00b0W<br \/>Commune : Behuard\/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_Na_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_Na_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_Na_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Ile Mureau","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-mureau\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ile Mureau\" width=\"300\" height=\"175\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Na_5-Site-de-collecte-laisse-Nord-300x175.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.370982","%_wpgmp_metabox_longitude%":"-0.675120","%_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:\"22\";}","%refpoint%":"PAL_20-21_Na_5","%_wp_page_template%":"default","%_thumbnail_id%":"4001","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":7169,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Jean de Lattre de Tassigny","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 de Lattre de Tassigny<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \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 class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e Jean de Lattre de Tassigny\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_6_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e De Lattre de Tassigny<\/h2>\n<p>Commune : La Roche-sur-Yon<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>34 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Veillon\" de la commune Talmont Saint-Hilaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_6_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_Na_6_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_Na_6_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2019-2020","location":{"lat":"46.67524822316609","lng":"-1.405390588243922","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-jean-de-lattre-de-tassigny\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2019-2020","post_content":"<h2>Lyc\u00e9e De Lattre de Tassigny<\/h2>\n<p>Commune : La Roche-sur-Yon<br>Acad\u00e9mie : Nantes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>34 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Veillon\" de la commune Talmont Saint-Hilaire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_6_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_Na_6_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_Na_6_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Jean de Lattre de Tassigny","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-jean-de-lattre-de-tassigny\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e Jean de Lattre de Tassigny\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Na_6_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.67524822316609","%_wpgmp_metabox_longitude%":"-1.405390588243922","%_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:\"22\";}","%refpoint%":"PAL_19-20_Na_6#","%_wp_page_template%":"default","%_thumbnail_id%":"1602","taxonomy=type-site-classe":"Classes","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-classe.png"},"id":7172,"custom_filters":{"%type-site-classe%":["Classes"],"%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-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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Chalonnes sur Loire","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 Chalonnes sur Loire<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Chalonnes sur Loire \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 id=\"contenu_article\"><h2 class=\"site\">Berge de Chalonnes sur Loire<\/h2>\n<p>Latitude : 47.3515833N | Longitude : 0.7450000W<br \/>Commune : Chalonnes sur Loire<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p><\/div><\/div>","content":"Chalonnes sur Loire \u2022 2022-2023","location":{"lat":"47.3515833","lng":"-0.7450000","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-chalonnes-sur-loire\/","zoom":7,"extra_fields":{"post_excerpt":"Chalonnes sur Loire \u2022 2022-2023","post_content":"<h2 class=\"site\">Berge de Chalonnes sur Loire<\/h2>\n<p>Latitude : 47.3515833N | Longitude : 0.7450000W<br \/>Commune : Chalonnes sur Loire<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>","post_title":"Berge de Chalonnes sur Loire","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-chalonnes-sur-loire\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.3515833","%_wpgmp_metabox_longitude%":"-0.7450000","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_59","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":8539,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Saint Exup\u00e9ry","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 Exup\u00e9ry<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\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 id=\"contenu_article\"><h2>Coll\u00e8ge Saint Exup\u00e9ry<\/h2>\n<p>Commune\u00a0: Chalonnes sur Loire<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Chalonnes sur Loire\". Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p><\/div><\/div>","content":"6\u00e8me \u2022 2022-2023","location":{"lat":"47.34651867700959","lng":"-0.7760082174283977","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-exupery-2\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Saint Exup\u00e9ry<\/h2>\n<p>Commune\u00a0: Chalonnes sur Loire<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Chalonnes sur Loire\". Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>","post_title":"Coll\u00e8ge Saint Exup\u00e9ry","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-exupery-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.34651867700959","%_wpgmp_metabox_longitude%":"-0.7760082174283977","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_59#","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":8540,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"\u00c9tang du Lys","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\">\u00c9tang du Lys<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Lys-Haut-Layon \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 id=\"contenu_article\"><h2 class=\"site\">\u00c9tang du Lys<\/h2>\n<p>Latitude : 47.1448922N | Longitude : 0.54734387744W<br \/>Commune : Lys-Haut-Layon<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p><\/div><\/div>","content":"Lys-Haut-Layon \u2022 2022-2023","location":{"lat":"47.144892272557705","lng":"-0.5473438774443257","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/etang-du-lys\/","zoom":7,"extra_fields":{"post_excerpt":"Lys-Haut-Layon \u2022 2022-2023","post_content":"<h2 class=\"site\">\u00c9tang du Lys<\/h2>\n<p>Latitude : 47.1448922N | Longitude : 0.54734387744W<br \/>Commune : Lys-Haut-Layon<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>","post_title":"\u00c9tang du Lys","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/etang-du-lys\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.144892272557705","%_wpgmp_metabox_longitude%":"-0.5473438774443257","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_60","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":8541,"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":"Nantes","id":"22","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Vall\u00e9e Du Lys","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 Vall\u00e9e Du Lys<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\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 id=\"contenu_article\"><h2>Coll\u00e8ge Vall\u00e9e Du Lys<\/h2>\n<p>Commune\u00a0: Lys-Haut-Layon<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>78 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"\u00c9tang du Lys\". Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p><\/div><\/div>","content":"6\u00e8me \u2022 2022-2023","location":{"lat":"47.1447388095572","lng":"-0.5273920002370261","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-vallee-du-lys\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Vall\u00e9e Du Lys<\/h2>\n<p>Commune\u00a0: Lys-Haut-Layon<br>Acad\u00e9mie : Nantes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>78 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"\u00c9tang du Lys\". Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>","post_title":"Coll\u00e8ge Vall\u00e9e Du Lys","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-vallee-du-lys\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.1447388095572","%_wpgmp_metabox_longitude%":"-0.5273920002370261","%_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:\"22\";}","%refpoint%":"PAL_22-23_Na_60#","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":8542,"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":"Nantes","id":"22","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"}}