Académie de Grenoble

Académie Amiens
Accompagnement académique

IPR Référent : Annie Boisbouvier
Contact : Geneviève Baret, genevieve.baret@ac-grenoble.fr

{"map_options":{"center_lat":"45.655658478378214","center_lng":"5.861387113497636","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":"Plage du Bourget","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 Bourget<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Le Bourget-du-Lac \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 du Bourget\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-11_2_Photo_Laisse-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage du Bourget<\/h2>\n<p>Latitude : 45.6556584783\u00b0N | Longitude : 5.861387113 E<br \/>Commune : Le Bourget-du-Lac<\/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-Gr-11FM.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-Gr-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Le Bourget-du-Lac \u2022 2022-2023","address":"","location":{"lat":"45.655658478378214","lng":"5.861387113497636","redirect_custom_link":"","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-bourget\/","zoom":7,"extra_fields":{"post_excerpt":"Le Bourget-du-Lac \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage du Bourget<\/h2>\n<p>Latitude : 45.6556584783\u00b0N | Longitude : 5.861387113 E<br \/>Commune : Le Bourget-du-Lac<\/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-Gr-11FM.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-Gr-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage du Bourget","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-bourget\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage du Bourget\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-11_2_Photo_Laisse-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.655658478378214","%_wpgmp_metabox_longitude%":"5.861387113497636","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_11","%_wp_page_template%":"default","%_thumbnail_id%":"11020","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":8212,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Saint Fran\u00e7ois De Sales","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 Fran\u00e7ois De Sales<\/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 Saint Fran\u00e7ois De Sales\" width=\"300\" height=\"168\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-11-photo-classe-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Saint Fran\u00e7ois De Sales<\/h2>\n<p>Commune\u00a0: Chambery<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>33 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Bourget\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-11FM.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-Gr-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2022-2023","location":{"lat":"45.56932129985244","lng":"5.92665137087288","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-francois-de-sales\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Saint Fran\u00e7ois De Sales<\/h2>\n<p>Commune\u00a0: Chambery<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>33 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Bourget\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-11FM.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-Gr-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Saint Fran\u00e7ois De Sales","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-francois-de-sales\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Saint Fran\u00e7ois De Sales\" width=\"300\" height=\"168\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-11-photo-classe-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.56932129985244","%_wpgmp_metabox_longitude%":"5.92665137087288","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_11#","%_wp_page_template%":"default","%_thumbnail_id%":"11024","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":8213,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage d&rsquo;Excenevex","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 d&rsquo;Excenevex<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Excenevex \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 d&rsquo;Excenevex\" width=\"256\" height=\"192\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-13_1_Site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage d'Excenevex<\/h2>\n<p>Latitude : 46.3478509\u00b0N | Longitude : 6.3581781 E<br \/>Commune : Excenevex<\/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-Gr-13FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-13FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Excenevex \u2022 2022-2023","location":{"lat":"46.3478509","lng":"6.3581781","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-dexcenevex\/","zoom":7,"extra_fields":{"post_excerpt":"Excenevex \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage d'Excenevex<\/h2>\n<p>Latitude : 46.3478509\u00b0N | Longitude : 6.3581781 E<br \/>Commune : Excenevex<\/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-Gr-13FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-13FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage d&rsquo;Excenevex","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-dexcenevex\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage d&rsquo;Excenevex\" width=\"256\" height=\"192\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-13_1_Site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.3478509","%_wpgmp_metabox_longitude%":"6.3581781","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_13","%_wp_page_template%":"default","%_thumbnail_id%":"11019","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":8216,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Du Bas Chablais","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 Du Bas Chablais<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                4\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 Du Bas Chablais\" width=\"256\" height=\"192\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Eleves_PAL-22-23-Gr13-photo-classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Du Bas Chablais<\/h2>\n<p>Commune\u00a0: Douvaine<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>26 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage d'Excenevex\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-13FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-13FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2022-2023","location":{"lat":"46.30502501150495","lng":"6.308260967190767","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-du-bas-chablais\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Du Bas Chablais<\/h2>\n<p>Commune\u00a0: Douvaine<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>26 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage d'Excenevex\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-13FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-13FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Du Bas Chablais","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-du-bas-chablais\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Du Bas Chablais\" width=\"256\" height=\"192\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Eleves_PAL-22-23-Gr13-photo-classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.30502501150495","%_wpgmp_metabox_longitude%":"6.308260967190767","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_13#","%_wp_page_template%":"default","%_thumbnail_id%":"11026","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":8217,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du lac de Passy","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 lac de Passy<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Passy \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 du lac de Passy\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-14-site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage du lac de Passy<\/h2>\n<p>Latitude : 45.9220\u00b0N | Longitude : 6.6522856E<br \/>Commune : Passy <\/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-Gr-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-Gr-14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Passy \u2022 2022-2023","location":{"lat":"45.92208","lng":"6.6522856","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-lac-de-passy\/","zoom":7,"extra_fields":{"post_excerpt":"Passy \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage du lac de Passy<\/h2>\n<p>Latitude : 45.9220\u00b0N | Longitude : 6.6522856E<br \/>Commune : Passy <\/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-Gr-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-Gr-14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage du lac de Passy","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-lac-de-passy\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage du lac de Passy\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-14-site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.92208","%_wpgmp_metabox_longitude%":"6.6522856","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_14","%_wp_page_template%":"default","%_thumbnail_id%":"11018","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":8218,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Luzier","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 Luzier<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Luzier \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 Luzier\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-15-1_Photo_Site2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Luzier<\/h2>\n<p>Latitude : 45.96553196\u00b0N | Longitude : 6.6308 E<br \/>Commune : Luzier<\/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-Gr-15FM.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-Gr-15FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Luzier \u2022 2022-2023","location":{"lat":"45.96553196605211","lng":"6.6308953369488055","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-luzier\/","zoom":7,"extra_fields":{"post_excerpt":"Luzier \u2022 2022-2023","post_content":"<h2 class=\"site\">Berge de Luzier<\/h2>\n<p>Latitude : 45.96553196\u00b0N | Longitude : 6.6308 E<br \/>Commune : Luzier<\/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-Gr-15FM.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-Gr-15FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Berge de Luzier","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-luzier\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Luzier\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-15-1_Photo_Site2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.96553196605211","%_wpgmp_metabox_longitude%":"6.6308953369488055","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_15","%_wp_page_template%":"default","%_thumbnail_id%":"11017","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":8220,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Ecs 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\">Ecs Coll\u00e8ge Saint Joseph<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Terminal \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=\"Ecs Coll\u00e8ge Saint Joseph\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-15-1_Photo_Site2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Ecs Coll\u00e8ge Saint Joseph<\/h2>\n<p>Commune\u00a0: Sallanches<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>60 \u00e9l\u00e8ves de terminal<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Luzier\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-15FM.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-Gr-15FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Terminal \u2022 2022-2023","location":{"lat":"45.94212977471695","lng":"6.642420528557943","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ecs-college-saint-joseph\/","zoom":7,"extra_fields":{"post_excerpt":"Terminal \u2022 2022-2023","post_content":"<h2>Ecs Coll\u00e8ge Saint Joseph<\/h2>\n<p>Commune\u00a0: Sallanches<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>60 \u00e9l\u00e8ves de terminal<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Luzier\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-15FM.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-Gr-15FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Ecs Coll\u00e8ge Saint Joseph","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ecs-college-saint-joseph\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ecs Coll\u00e8ge Saint Joseph\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-15-1_Photo_Site2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.94212977471695","%_wpgmp_metabox_longitude%":"6.642420528557943","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_15#","%_wp_page_template%":"default","%_thumbnail_id%":"11017","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":8221,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Marignier","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 Marignier<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Marignier \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 Marignier\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-17-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Marignier<\/h2>\n<p>Latitude : 46.077266 \u00b0N | Longitude : 6.493220 E<br \/>Commune : Bi\u00e8vres<\/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_Gr-17_0FM.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\/07\/PAL_22_23_Gr-17_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Marignier \u2022 2022-2023","location":{"lat":"46.077266","lng":"6.493220","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-marignier\/","zoom":7,"extra_fields":{"post_excerpt":"Marignier \u2022 2022-2023","post_content":"<h2 class=\"site\">Berge de Marignier<\/h2>\n<p>Latitude : 46.077266 \u00b0N | Longitude : 6.493220 E<br \/>Commune : Bi\u00e8vres<\/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_Gr-17_0FM.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\/07\/PAL_22_23_Gr-17_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Berge de Marignier","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-marignier\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Marignier\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-17-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.077266","%_wpgmp_metabox_longitude%":"6.493220","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_17","%_wp_page_template%":"default","%_thumbnail_id%":"11015","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":8224,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Saint Julien en Genevois","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 Julien en Genevois<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Julien en Genevois \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 Saint Julien en Genevois\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Gr-20-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Saint Julien en Genevois<\/h2>\n<p>Latitude : 46.1382500\u00b0N | Longitude : 6.0679722 E<br \/>Commune : Saint Julien en Genevois<\/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-Gr-20FM.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-Gr-20FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Saint Julien en Genevois \u2022 2022-2023","location":{"lat":"46.1382500","lng":"6.0679722","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-saint-julien-en-genevois\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Julien en Genevois \u2022 2022-2023","post_content":"<h2 class=\"site\">Berge de Saint Julien en Genevois<\/h2>\n<p>Latitude : 46.1382500\u00b0N | Longitude : 6.0679722 E<br \/>Commune : Saint Julien en Genevois<\/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-Gr-20FM.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-Gr-20FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Berge de Saint Julien en Genevois","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-saint-julien-en-genevois\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Saint Julien en Genevois\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Gr-20-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.1382500","%_wpgmp_metabox_longitude%":"6.0679722","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_20","%_wp_page_template%":"default","%_thumbnail_id%":"11014","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":8228,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Mme De Sta\u00ebl","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 Mme De Sta\u00ebl<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Lyc\u00e9e \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 Mme De Sta\u00ebl\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Gr-20-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Mme De Sta\u00ebl<\/h2>\n<p>Commune\u00a0: Saint Julien en Genevois<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Julien en Genevois\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-20FM.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-Gr-20FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Lyc\u00e9e \u2022 2022-2023","location":{"lat":"46.14195392020255","lng":"6.0709120671851755","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-mme-de-stael\/","zoom":7,"extra_fields":{"post_excerpt":"Lyc\u00e9e \u2022 2022-2023","post_content":"<h2>Lyc\u00e9e Mme De Sta\u00ebl<\/h2>\n<p>Commune\u00a0: Saint Julien en Genevois<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Julien en Genevois\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-20FM.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-Gr-20FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Lyc\u00e9e Mme De Sta\u00ebl","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-mme-de-stael\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e Mme De Sta\u00ebl\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Gr-20-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.14195392020255","%_wpgmp_metabox_longitude%":"6.0709120671851755","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_20#","%_wp_page_template%":"default","%_thumbnail_id%":"11014","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":8229,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Pont de Chartreuse","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 Chartreuse<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Grenoble \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=\"Pont de Chartreuse\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-2_1_Photo_Site-225x300.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Pont de Chartreuse<\/h2>\n<p>Latitude : 45.1991667\u00b0N | Longitude : 5.7341667\u00b0E<br \/>Commune : Grenoble<\/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-Gr-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_2_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_2_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Grenoble \u2022 2021-2022-2023","location":{"lat":"45.1991667","lng":"5.7341667","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-chartreuse\/","zoom":7,"extra_fields":{"post_excerpt":"Grenoble \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Pont de Chartreuse<\/h2>\n<p>Latitude : 45.1991667\u00b0N | Longitude : 5.7341667\u00b0E<br \/>Commune : Grenoble<\/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-Gr-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_2_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_2_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Pont de Chartreuse","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-chartreuse\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pont de Chartreuse\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-2_1_Photo_Site-225x300.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.1991667","%_wpgmp_metabox_longitude%":"5.7341667","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_2","%_wp_page_template%":"default","%_thumbnail_id%":"11022","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":5392,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Marcel Mariotte","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 Marcel Mariotte<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                4\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 Marcel Mariotte\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-2-photo-classe-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Marcel Mariotte<\/h2>\n<p>Commune\u00a0: Saint-Sim\u00e9on-de-Bressieux<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>116 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \"Pont de Chartreuse\" et \"Pont sur l'Is\u00e8re\" de la commune de Grenoble.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2022-2023","location":{"lat":"45.327349873694104","lng":"5.267666074830111","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-marcel-mariotte\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Marcel Mariotte<\/h2>\n<p>Commune\u00a0: Saint-Sim\u00e9on-de-Bressieux<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>116 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \"Pont de Chartreuse\" et \"Pont sur l'Is\u00e8re\" de la commune de Grenoble.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Marcel Mariotte","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-marcel-mariotte\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Marcel Mariotte\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-2-photo-classe-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.327349873694104","%_wpgmp_metabox_longitude%":"5.267666074830111","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_2#","%_wp_page_template%":"default","%_thumbnail_id%":"11025","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":8205,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage des Mottets","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 Mottets<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Aix les Bains \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 Mottets<\/h2>\n<p>Latitude : 45.6513889\u00b0N | Longitude : 5.8833333\u00b0E<br \/>Commune : Aix les Bains<\/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_Gr_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Gr_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Aix les Bains \u2022 2021-2022-2023","location":{"lat":"45.6513889","lng":"5.8833333","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-mottets\/","zoom":7,"extra_fields":{"post_excerpt":"Aix les Bains \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Plage des Mottets<\/h2>\n<p>Latitude : 45.6513889\u00b0N | Longitude : 5.8833333\u00b0E<br \/>Commune : Aix les Bains<\/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_Gr_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Gr_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Plage des Mottets","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-mottets\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.6513889","%_wpgmp_metabox_longitude%":"5.8833333","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_5","%_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":5399,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Garibaldi","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 Garibaldi<\/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 Garibaldi<\/h2>\n<p>Commune\u00a0: aix les bains<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>62 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Mottets\" de la commune de Aix les Bains.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Gr_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Gr_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2021-2022-2023","location":{"lat":"45.703082498880256","lng":"5.891352237319189","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-garibaldi\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2021-2022-2023","post_content":"<h2>Coll\u00e8ge Garibaldi<\/h2>\n<p>Commune\u00a0: aix les bains<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>62 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Mottets\" de la commune de Aix les Bains.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Gr_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Gr_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Garibaldi","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-garibaldi\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.703082498880256","%_wpgmp_metabox_longitude%":"5.891352237319189","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_5#","%_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":5400,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Saint Jean de Soudain","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 Jean de Soudain<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Jean de Soudain \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 Jean de Soudain\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-6-3_Photo_PollutionSite-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Saint Jean de Soudain<\/h2>\n<p>Latitude : 45.569837\u00b0N | Longitude :  5.433314\u00b0E<br \/>Commune : Saint Jean de Soudain<\/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-Gr-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint Jean de Soudain \u2022 2021-2022-2023","location":{"lat":"45.569837","lng":"5.433314","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-saint-jean-de-soudain\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Jean de Soudain \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Berge de Saint Jean de Soudain<\/h2>\n<p>Latitude : 45.569837\u00b0N | Longitude :  5.433314\u00b0E<br \/>Commune : Saint Jean de Soudain<\/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-Gr-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge de Saint Jean de Soudain","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-saint-jean-de-soudain\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Saint Jean de Soudain\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Gr-6-3_Photo_PollutionSite-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.569837","%_wpgmp_metabox_longitude%":"5.433314","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_6","%_wp_page_template%":"default","%_thumbnail_id%":"11021","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":5401,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Saint Jean Bosco","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 Jean Bosco<\/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 Jean Bosco<\/h2>\n<p>Commune\u00a0: Cluses<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>29 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Marignier\" de la commune de Bi\u00e8vres.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Gr-17_0FM.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\/07\/PAL_22_23_Gr-17_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h6>En vid\u00e9o<\/h6>\n<ul>\nvimeo.com\/user128898648\/\nvimeo.com\/user128898648\/\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2022-2023","location":{"lat":"46.05961207995373","lng":"6.578471767182409","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-jean-bosco\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Saint Jean Bosco<\/h2>\n<p>Commune\u00a0: Cluses<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>29 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Marignier\" de la commune de Bi\u00e8vres.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Gr-17_0FM.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\/07\/PAL_22_23_Gr-17_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h6>En vid\u00e9o<\/h6>\n<ul>\nvimeo.com\/user128898648\/\nvimeo.com\/user128898648\/\n<\/ul>","post_title":"Coll\u00e8ge Saint Jean Bosco","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-jean-bosco\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.05961207995373","%_wpgmp_metabox_longitude%":"6.578471767182409","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_17#","%_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":8225,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge les dauphins","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge les dauphins<\/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 les dauphins<\/h2>\n<p>Commune\u00a0: St Jean de Soudain<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Jean de Soudain\" de la commune de Saint Jean de Soudain.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>150 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Jean de Soudain\" de la commune de Saint Jean de Soudain. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2021-2022-2023","location":{"lat":"45.562642350484055","lng":"5.430840935487482","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-les-dauphins\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2021-2022-2023","post_content":"<h2>Coll\u00e8ge les dauphins<\/h2>\n<p>Commune\u00a0: St Jean de Soudain<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Jean de Soudain\" de la commune de Saint Jean de Soudain.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>150 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Jean de Soudain\" de la commune de Saint Jean de Soudain. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge les dauphins","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-les-dauphins\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.562642350484055","%_wpgmp_metabox_longitude%":"5.430840935487482","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_6#","%_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":5402,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge De Varens, Passy","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 De Varens, Passy<\/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 De Varens<\/h2>\n<p>Commune\u00a0: Passy<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>200 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du lac de Passy\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-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-Gr-14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2022-2023","location":{"lat":"45.91415470347369","lng":"6.700658499720776","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-de-varens-passy\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge De Varens<\/h2>\n<p>Commune\u00a0: Passy<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>200 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du lac de Passy\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Gr-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-Gr-14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge De Varens, Passy","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-de-varens-passy\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.91415470347369","%_wpgmp_metabox_longitude%":"6.700658499720776","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_14#","%_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":8219,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Saint-Jorioz","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-Jorioz<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint-Jorioz \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 Saint-Jorioz<\/h2>\n<p>Latitude : 45.843949\u00b0N | Longitude : 6.172894\u00b0E<br \/>Commune : Saint-Jorioz<\/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\/06\/PAL_21-22_Gr_-1-_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_-1-_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_-1-_D.xlsx\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint-Jorioz \u2022 2021-2022","location":{"lat":"45.843949","lng":"6.172894","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-saint-jorioz\/","zoom":7,"extra_fields":{"post_excerpt":"Saint-Jorioz \u2022 2021-2022","post_content":"<h2 class=\"site\">Plage de Saint-Jorioz<\/h2>\n<p>Latitude : 45.843949\u00b0N | Longitude : 6.172894\u00b0E<br \/>Commune : Saint-Jorioz<\/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\/06\/PAL_21-22_Gr_-1-_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_-1-_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_-1-_D.xlsx\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de Saint-Jorioz","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-saint-jorioz\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.843949","%_wpgmp_metabox_longitude%":"6.172894","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_1","%_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":5390,"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":"Grenoble","id":"11","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                Coll\u00e8ge \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 Jean Monnet<\/h2>\n<p>Commune\u00a0: Saint-Jorioz<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n\n<h4>60 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Saint-Jorioz\" de la commune de Saint-Jorioz. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_-1-_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_-1-_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_-1-_D.xlsx\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2021-2022","location":{"lat":"45.836196621678056","lng":"6.1627519349807045","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-monnet-2\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Jean Monnet<\/h2>\n<p>Commune\u00a0: Saint-Jorioz<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n\n<h4>60 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Saint-Jorioz\" de la commune de Saint-Jorioz. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_-1-_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_-1-_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_-1-_D.xlsx\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jean Monnet","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-monnet-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_old_slug%":"college-jean-monnet-3","%_wpgmp_metabox_latitude%":"45.836196621678056","%_wpgmp_metabox_longitude%":"6.1627519349807045","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_1#","%_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":5391,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Stendhal","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 Stendhal<\/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 Stendhal<\/h2>\n<p>Commune\u00a0: Grenoble<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n\n<h4>70 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \"Pont de Chartreuse\" et \"Pont sur l'Is\u00e8re\" de la commune de Grenoble. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_2_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_2_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2021-2022","location":{"lat":"45.19019160039356","lng":"5.730312647138799","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-stendhal\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2021-2022","post_content":"<h2>Lyc\u00e9e Stendhal<\/h2>\n<p>Commune\u00a0: Grenoble<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n\n<h4>70 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \"Pont de Chartreuse\" et \"Pont sur l'Is\u00e8re\" de la commune de Grenoble. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_2_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_2_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Stendhal","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-stendhal\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.19019160039356","%_wpgmp_metabox_longitude%":"5.730312647138799","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_2#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5393,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Pont sur l&rsquo;Is\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\">Pont sur l&rsquo;Is\u00e8re<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Grenoble \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\">Pont sur l'Is\u00e8re<\/h2>\n<p>Latitude : 45.1933\u00b0N | Longitude : 5.7194\u00b0E<br \/>Commune : Grenoble<\/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\/06\/PAL_21-22_Gr_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Grenoble \u2022 2021-2022","location":{"lat":"45.1933","lng":"5.7194","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-sur-lisere\/","zoom":7,"extra_fields":{"post_excerpt":"Grenoble \u2022 2021-2022","post_content":"<h2 class=\"site\">Pont sur l'Is\u00e8re<\/h2>\n<p>Latitude : 45.1933\u00b0N | Longitude : 5.7194\u00b0E<br \/>Commune : Grenoble<\/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\/06\/PAL_21-22_Gr_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Pont sur l&rsquo;Is\u00e8re","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-sur-lisere\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.1933","%_wpgmp_metabox_longitude%":"5.7194","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_9","%_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":5394,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge d&rsquo;Albertville","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;Albertville<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Albertville \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'Albertville<\/h2>\n<p>Latitude : 45.679759\u00b0N | Longitude : 6.39633464\u00b0E<br \/>Commune : Albertville<\/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\/06\/PAL_21-22_Gr_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Albertville \u2022 2021-2022","location":{"lat":"45.67975997924805","lng":"6.396334648132324","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-dalbertville\/","zoom":7,"extra_fields":{"post_excerpt":"Albertville \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge d'Albertville<\/h2>\n<p>Latitude : 45.679759\u00b0N | Longitude : 6.39633464\u00b0E<br \/>Commune : Albertville<\/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\/06\/PAL_21-22_Gr_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge d&rsquo;Albertville","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-dalbertville\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.67975997924805","%_wpgmp_metabox_longitude%":"6.396334648132324","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_3","%_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":5395,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Jean d arc","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 d arc<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me et 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>Coll\u00e8ge Jean d arc<\/h2>\n<p>Commune\u00a0: Albertville<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n\n<h4>75 \u00e9l\u00e8ves de 6\u00e8me et 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge d'Albertville\" de la commune de Albertville. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me et 3\u00e8me \u2022 2021-2022","location":{"lat":"45.678072607176816","lng":"6.390226222010674","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-d-arc\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me et 3\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Jean d arc<\/h2>\n<p>Commune\u00a0: Albertville<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n\n<h4>75 \u00e9l\u00e8ves de 6\u00e8me et 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge d'Albertville\" de la commune de Albertville. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jean d arc","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-d-arc\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.678072607176816","%_wpgmp_metabox_longitude%":"6.390226222010674","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_3#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5396,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Port d&rsquo;Aix les Bains","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 d&rsquo;Aix les Bains<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Aix les Bains \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\">Port d'Aix les Bains<\/h2>\n<p>Latitude : 45.701188\u00b0N | Longitude : 5.8833333\u00b0E<br \/>Commune : Aix les Bains<\/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\/06\/PAL_21-22_Gr_4_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Aix les Bains \u2022 2021-2022","location":{"lat":"45.701188","lng":"5.883358","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/port-daix-les-bains\/","zoom":7,"extra_fields":{"post_excerpt":"Aix les Bains \u2022 2021-2022","post_content":"<h2 class=\"site\">Port d'Aix les Bains<\/h2>\n<p>Latitude : 45.701188\u00b0N | Longitude : 5.8833333\u00b0E<br \/>Commune : Aix les Bains<\/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\/06\/PAL_21-22_Gr_4_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Port d&rsquo;Aix les Bains","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/port-daix-les-bains\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.701188","%_wpgmp_metabox_longitude%":"5.883358","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_4","%_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":5397,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Jean Jacques Perret","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 Jacques Perret<\/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 Jean Jacques Perret<\/h2>\n<p>Commune\u00a0: aix les bains<br>Acad\u00e9mie : Grenoble<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>43 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Port d'Aix les Bains\" de la commune de Aix les Bains. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_4_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022","location":{"lat":"45.69331716997049","lng":"5.915236268036662","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-jacques-perret\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Jean Jacques Perret<\/h2>\n<p>Commune\u00a0: aix les bains<br>Acad\u00e9mie : Grenoble<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>43 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Port d'Aix les Bains\" de la commune de Aix les Bains. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_4_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jean Jacques Perret","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-jacques-perret\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.69331716997049","%_wpgmp_metabox_longitude%":"5.915236268036662","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_4#","%_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":5398,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Glun","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 Glun<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Glun \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 Glun<\/h2>\n<p>Latitude : 45.0127778\u00b0N | Longitude : 4.8361111\u00b0E<br \/>Commune : Glun<\/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_Gr_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\/2022\/07\/PAL_21-22_Gr_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\/2022\/07\/PAL_21-22_Gr_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Glun \u2022 2021-2022","location":{"lat":"45.0127778","lng":"4.8361111","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-glun\/","zoom":7,"extra_fields":{"post_excerpt":"Glun \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Glun<\/h2>\n<p>Latitude : 45.0127778\u00b0N | Longitude : 4.8361111\u00b0E<br \/>Commune : Glun<\/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_Gr_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\/2022\/07\/PAL_21-22_Gr_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\/2022\/07\/PAL_21-22_Gr_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge de Glun","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-glun\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.0127778","%_wpgmp_metabox_longitude%":"4.8361111","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_7","%_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":5403,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Institution Notre Dame","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 Notre Dame<\/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>Institution Notre Dame<\/h2>\n<p>Commune\u00a0: Valence<br>Acad\u00e9mie : Grenoble<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>85 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Glun\" de la commune de Glun. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Gr_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\/2022\/07\/PAL_21-22_Gr_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\/2022\/07\/PAL_21-22_Gr_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2021-2022","location":{"lat":"45.16842394104088","lng":"5.70645325084622","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/institution-notre-dame\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2021-2022","post_content":"<h2>Institution Notre Dame<\/h2>\n<p>Commune\u00a0: Valence<br>Acad\u00e9mie : Grenoble<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>85 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Glun\" de la commune de Glun. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Gr_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\/2022\/07\/PAL_21-22_Gr_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\/2022\/07\/PAL_21-22_Gr_7FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Institution Notre Dame","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/institution-notre-dame\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.16842394104088","%_wpgmp_metabox_longitude%":"5.70645325084622","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_7#","%_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":5404,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Fontaine","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 Fontaine<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Fontaine \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 Fontaine<\/h2>\n<p>Latitude : 45.2013441\u00b0N | Longitude : 5.693181\u00b0E<br \/>Commune : Fontaine<\/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\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Fontaine \u2022 2021-2022","location":{"lat":"45.2013441","lng":"5.693181","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-fontaine\/","zoom":7,"extra_fields":{"post_excerpt":"Fontaine \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Fontaine<\/h2>\n<p>Latitude : 45.2013441\u00b0N | Longitude : 5.693181\u00b0E<br \/>Commune : Fontaine<\/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\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge de Fontaine","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-fontaine\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.2013441","%_wpgmp_metabox_longitude%":"5.693181","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_8","%_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":5405,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e 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\">Lyc\u00e9e Louise Michel<\/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 Louise Michel<\/h2>\n<p>Commune\u00a0: Grenoble<br>Acad\u00e9mie : Grenoble<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Fontaine\" de la commune de Fontaine. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2021-2022","location":{"lat":"45.16842394104088","lng":"5.70645325084622","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-louise-michel\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2021-2022","post_content":"<h2>Lyc\u00e9e Louise Michel<\/h2>\n<p>Commune\u00a0: Grenoble<br>Acad\u00e9mie : Grenoble<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Fontaine\" de la commune de Fontaine. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_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\/2022\/06\/PAL_21-22_Gr_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Louise Michel","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-louise-michel\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"45.16842394104088","%_wpgmp_metabox_longitude%":"5.70645325084622","%_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:\"11\";}","%refpoint%":"PAL_21-22_Gr_8#","%_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":5406,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Guilherand-Granges","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 Guilherand-Granges<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Guilherand-Granges \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 Guilherand-Granges<\/h2>\n<p>Latitude : 44.94447\u00b0N | Longitude : 4.87929 E<br \/>Commune : Guilherand-Granges<\/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":"Guilherand-Granges \u2022 2022-2023","location":{"lat":"44.94447","lng":"4.87929","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-guilherand-granges\/","zoom":7,"extra_fields":{"post_excerpt":"Guilherand-Granges \u2022 2022-2023","post_content":"<h2 class=\"site\">Berge de Guilherand-Granges<\/h2>\n<p>Latitude : 44.94447\u00b0N | Longitude : 4.87929 E<br \/>Commune : Guilherand-Granges<\/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 Guilherand-Granges","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-guilherand-granges\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"44.94447","%_wpgmp_metabox_longitude%":"4.87929","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_10","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":8210,"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":"Grenoble","id":"11","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Camille Vernet","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 Camille Vernet<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                4\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 Camille Vernet<\/h2>\n<p>Commune\u00a0: Valence<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Guilherand-Granges\". Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p><\/div><\/div>","content":"4\u00e8me \u2022 2022-2023","location":{"lat":"44.92430912239949","lng":"4.9032996536528595","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-camille-vernet\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Camille Vernet<\/h2>\n<p>Commune\u00a0: Valence<br>Acad\u00e9mie : Grenoble<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Guilherand-Granges\". Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>","post_title":"Coll\u00e8ge Camille Vernet","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-camille-vernet\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"44.92430912239949","%_wpgmp_metabox_longitude%":"4.9032996536528595","%_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:\"11\";}","%refpoint%":"PAL_22-23_Gr_10#","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":8211,"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":"Grenoble","id":"11","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"}}