Bulgarian Academy of Sciences
Address:
Bulgaria, Sofia, 1040
1 “15 Noemvri” Str.
Phone:
(+359 2) 979 53 33
(+359 2) 979 52 23
Registry Office:
Phone/Fax: 02 981 72 62
Phone: 02 979 52 63
E-mail: office@cu.bas.bg
Protocol:
Phone: (+359 2) 979 52 67
E-mail: emili@cu.bas.bg
Public Relations:
Phone: (+359 2) 979 52 80
E-mail: pr-ban@cu.bas.bg
{"map_options":{"center_lat":"42.688464","center_lng":"23.350706","zoom":14,"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://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images//default_marker.png","draggable":true,"scroll_wheel":"false","gesture":"auto","marker_default_icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.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\t{post_featured_image}\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">{post_title}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: {%acf_bas_address%}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: {%acf_bas_phone%}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: {%acf_bas_site%}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"{post_link}\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","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":"aare","type":"post","sourcecode":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t{post_featured_image}\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">{post_title}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: {%acf_bas_address%}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: {%acf_bas_phone%}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: {%acf_bas_site%}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"{post_link}\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":true,"default_infowindow_open":false,"infowindow_open_event":"click","listing_infowindow_open_event":"click","is_mobile":false,"infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":false,"full_screen_control":true,"search_control":true,"zoom_control":true,"map_type_control":true,"street_view_control":true,"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":true,"current_post_only":false,"bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"600"},"places":[{"id":"4","title":"Bulgarian Academy of Sciences - Administration","address":"1 \"15 Noemvri\" Str., 1000 Sofia, Bulgaria","source":"manual","location":{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","lat":"42.69452","lng":"23.33214","city":"Sofia","state":"Sofia City Province","country":"Bulgaria","onclick_action":"marker","open_new_tab":"yes","postal_code":"1000","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":{"listorder":0}}},{"source":"post","title":"Climate, Atmosphere and Water Research Institute","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Climate, Atmosphere and Water Research Institute\" width=\"300\" height=\"206\" src=\"https://www.bas.bg/wp-content/uploads/2019/09/cawri_logo_en-300x206.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Climate, Atmosphere and Water Research Institute</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 66 Tsarigradsko shose Blvd., 1784 Sofia</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 887 507 283</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://cawri-bas.eu/\" target=\"_blank\" rel=\"noopener\">http://cawri-bas.eu/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=25950&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.6556167","lng":"23.385268","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=25950&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"66 Tsarigradsko shose Blvd., 1784 Sofia","%acf_bas_phone%":"+359 887 507 283","%acf_bas_site%":"<a href=\"http://cawri-bas.eu/\" target=\"_blank\" rel=\"noopener\">http://cawri-bas.eu/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"][acf field=\"acf_bas_deptname\"][/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><a href=\"https://www.bas.bg/wp-content/uploads/2019/09/cawri_logo_en.png\"><img class=\"size-medium wp-image-25398 alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2019/09/cawri_logo_en-300x206.png\" alt=\"\" width=\"300\" height=\"206\" /></a>[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Climate, Atmosphere and Water Research Institute</strong> was established by decision of the General Assembly of BAS on December 3, 2018 with the mission to conduct in BAS basic and applied interdisciplinary research in the field of:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>climate change,</li>\r\n \t<li>climate (including urban, coastal, mountainous and agro-climates),</li>\r\n \t<li>physicochemical processes in the atmosphere,</li>\r\n \t<li>water resources - conservation, use and development of related systems and services to meet the challenges of contemporary policies and strengthen the capacity of state institutions.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">Along with the achievement of new scientific knowledge, the aim of the research is to meet the needs of the society and the economy for knowledge and science-based policies for sustainable development and environmental protection.</p>\r\n<p style=\"text-align: justify;\">CAWRI-BAS is the successor of some of the traditional scientific studies in the BAS of atmospheric physics, climatology, climate change, the study and management of water resources. The founders and representatives of the respective schools in the BAS in these fields are Academician Stoicho Panchev, Corr. Member Dimitar Yordanov, Corr. Member Vasil Andreev and Academician Dimo \u200b\u200bVelev. The scientists at CAWRI-BAS are called upon to contribute to the preservation of the experience transmitted to them by the teachers, to develop the established schools and to extend the achievements in these fields.</p>\r\n<p style=\"text-align: justify;\">CAWRI-BAS is made up of 3 scientific sections: \"Climate\", \"Atmosphere\" and \"Water\".</p>\r\n<p style=\"text-align: justify;\">The staff of CAWRI-BAS is currently working in Sofia, Plovdiv and Burgas.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"][acf field=\"acf_bas_address\"][/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"][acf field=\"acf_bas_phone\"][/fusion_li_item][fusion_li_item icon=\"fa-at\"][acf field=\"acf_bas_email\"][/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Climate, Atmosphere and Water Research Institute","post_link":"https://www.bas.bg/?page_id=25950&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Climate, Atmosphere and Water Research Institute\" width=\"300\" height=\"206\" src=\"https://www.bas.bg/wp-content/uploads/2019/09/cawri_logo_en-300x206.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wpml_word_count%":"{\"total\":0,\"to_translate\":{\"bg\":2,\"en\":2}}","%_edit_lock%":"1569939583:18","%_edit_last%":"18","%_wp_page_template%":"default","%pyre_displayed_menu%":"default","%pyre_display_copyright%":"default","%pyre_display_footer%":"default","%pyre_display_header%":"yes","%pyre_elasticslider%":"0","%pyre_fallback%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_hundredp_padding%":"","%pyre_main_bottom_padding%":"","%pyre_main_top_padding%":"","%pyre_page_bg%":"","%pyre_page_bg_color%":"","%pyre_page_bg_full%":"default","%pyre_page_bg_layout%":"default","%pyre_page_bg_repeat%":"default","%pyre_page_title%":"default","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bg_parallax%":"default","%pyre_page_title_custom_subheader%":"","%pyre_page_title_text%":"default","%pyre_revslider%":"0","%pyre_show_first_featured_image%":"no","%pyre_sidebar_position%":"default","%pyre_slider%":"0","%pyre_slider_position%":"default","%pyre_slider_type%":"no","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg_full%":"default","%pyre_wide_page_bg_repeat%":"default","%pyre_wooslider%":"","%pyre_avada_rev_styles%":"default","%pyre_footer_100_width%":"default","%pyre_header_100_width%":"default","%pyre_page_title_100_width%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text_alignment%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_borders_color%":"","%fusion_builder_status%":"active","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_last_translation_edit_mode%":"native-editor","%pyre_fallback_id%":"","%pyre_demo_slider%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_custom_text%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"42.6556167","%_wpgmp_metabox_longitude%":"23.385268","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"25398","%_oembed_ce9cfe7ff1d03f50c9cdefea5289cab0%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://cawri-bas.eu/","%_gallery_link_target%":"_blank","%acf_bas_deptname%":"Climate, Atmosphere and Water Research Institute","%acf_bas_fax%":"","%acf_bas_email%":"<a href=\"mailto:director@cawri.bas.bg\">director@cawri.bas.bg</a>, <a href=\"mailto:office@cawri.bas.bg\">office@cawri.bas.bg</a>","%acf_bas_latitude%":"42.6556167","%acf_bas_longtitude%":"23.385268","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"default_sidebar","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"display_header":"yes","elasticslider":"0","header_bg_full":"no","header_bg_repeat":"repeat","revslider":"0","show_first_featured_image":"yes","slider":"0","slider_type":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"default_sidebar","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443326","%avada_post_views_count%":"802","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":25950,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Molecular Biology &#8220;Acad. Roumen Tsanev&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Molecular Biology &#8220;Acad. Roumen Tsanev&#8221;\" width=\"67\" height=\"71\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/imb-logo3.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Molecular Biology &#8220;Acad. Roumen Tsanev&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 21, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 872 8050</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.bio21.bas.bg/imb/\" target=\"_blank\" rel=\"noopener\">http://www.bio21.bas.bg/imb/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24341&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.672465","lng":"23.364706","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24341&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 21, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 872 8050","%acf_bas_site%":"<a href=\"http://www.bio21.bas.bg/imb/\" target=\"_blank\" rel=\"noopener\">http://www.bio21.bas.bg/imb/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"][acf field=\"acf_bas_deptname\"][/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/imb-logo3.png\" alt=\"\" width=\"67\" height=\"71\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Molecular Biology (IMB)</strong> is the leading national research institution in the area of molecular and cellular biology and biochemistry. IMB is a member of UNESCO Global Network for Molecular and Cell Biology since 1995. The mission of the Institute is:</p>\r\n\r\n<ol style=\"text-align: justify;\">\r\n \t<li>To conduct internationally-competitive basic and applied studies in the area of molecular biology and related disciplines of cellular and structural biology, molecular genetics and bioorganic chemistry and their applications in medicine and pharmacy.</li>\r\n \t<li>To prepare the next generation of scientists by offering high quality research training in its PhD programs. The Institute collaborates with leading national and foreign universities to promote teaching of molecular life sciences at various levels.</li>\r\n \t<li>To develop research projects with national and international scientific organizations and companies as a national and regional center for basic and applied research in cellular biology, epigenetics, proteomics, bioinformatics and bionanotechnology.</li>\r\n</ol>\r\n<p style=\"text-align: justify;\">IMB produces 40-50 high quality research papers per year published in peer-reviewed journals in the fields of molecular biology, molecular genetics, biochemistry and bio-organic chemistry.</p>\r\n<p style=\"text-align: justify;\">IMB collaborates and runs joint research projects with many universities and research institutes in Europe, Canada and the USA.</p>\r\n<p style=\"text-align: justify;\">IMB educates Ph.D. students in three disciplines: Molecular Biology, Molecular Genetics and Bioorganic Chemistry. The Institute has traditional bilateral co-operation with several Bulgarian universities for training undergraduate and graduate (MS) students in molecular biology, molecular genetics, biochemistry and bio-organic chemistry.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker-alt fas\"][acf field=\"acf_bas_address\"][/fusion_li_item][fusion_li_item icon=\"fa-phone-square fas\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax fas\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at fas\"][acf field=\"acf_bas_email\"][/fusion_li_item][fusion_li_item icon=\"fa-sitemap fas\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Molecular Biology &#8220;Acad. Roumen Tsanev&#8221;","post_link":"https://www.bas.bg/?page_id=24341&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Molecular Biology &#8220;Acad. Roumen Tsanev&#8221;\" width=\"67\" height=\"71\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/imb-logo3.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpml_word_count%":"{\"total\":358,\"to_translate\":{\"en\":358}}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_location_migration_done%":"1","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_fallback_id%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg%":"","%pyre_header_bg_id%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_responsive_sidebar_order%":"","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_id%":"","%pyre_page_bg_full%":"default","%pyre_page_bg_repeat%":"default","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_id%":"","%pyre_wide_page_bg_full%":"default","%pyre_wide_page_bg_repeat%":"default","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_font_color%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_retina_id%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"42.672465","%_wpgmp_metabox_longitude%":"23.364706","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Molecular Biology \"Acad. Roumen Tsanev\"","%acf_bas_fax%":"+359 2 979 3693","%acf_bas_email%":"<a href=\"mailto:imb@bio21.bas.bg\">imb@bio21.bas.bg</a>","%acf_bas_latitude%":"42.672465","%acf_bas_longtitude%":"23.364706","%_thumbnail_id%":"24339","%_edit_lock%":"1562847338:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"default_sidebar","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"default_sidebar","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443029","%avada_post_views_count%":"862","%avada_today_post_views_count%":"5","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24341,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Mechanics","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Mechanics\" width=\"300\" height=\"185\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/imech-300x185.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Mechanics</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 3, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 6420</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.imbm.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.imbm.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24042&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.6760081","lng":"23.370281100000057","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24042&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 3, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 6420","%acf_bas_site%":"<a href=\"http://www.imbm.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.imbm.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/08/IMech_LOGO.jpg\" alt=\"\" width=\"224\" height=\"197\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Mechanics (IMech) </strong>is a leading scientific center with longstanding traditions in fundamental and applied research in the fields of mechanics, robotics, mechatronics, biomechanics and related fields. It participates in the preparation of PhD students and highly qualified specialists, performs expert and innovation activities and directly applies scientific results into practice.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">IMech's main priorities are the development of the Institute's subject area in line with the global trends in mechanics, the realization of active international scientific cooperation and the participation in European Union trends and guidelines for the development of science.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Brief history of the unit</h6>\r\n<p style=\"text-align: justify;\" align=\"justify\">The Institute of Mechanics is a successor of the Institute of Technical Mechanics (ITM) founded in 1962. Later, the Institute of Mathematics and Mechanics and the Central Laboratory of Biomechanics were created in 1972 on the basis of personnel from the Institute of Technical Mechanics, the Mathematical Institute and the Institute of Water Problems. In 1977, the Central Laboratory of Biomechanics and the mechanics departments of the Institute of Mathematics and Mechanics were incorporated in the Institute of Mechanics and Biomechanics. It was renamed in 1993 to become the Institute of Mechanics. Since 1987, the Institute is housed in its own building. Its first Director, Academician Georgi Brankov, has major merit for the foundation and development of the Institute of Mechanics.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">The research and applied activity at the institute develops in 6 main areas:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>\r\n<p align=\"justify\">Mechatronics: modeling the dynamics of multibody systems, development of mechatronic and biomechatronic systems and devices oriented towards the human being; analysis and modelling of the movements of the human body in norm and pathology, development of mechatronic systems for rehabilitation, orthoses and prostheses; robotic systems for micromanipulations with biological cells and for orthopedic surgery; development and study of unmanned mobile platforms; synthesis and production of micro-modular gears; high-performance MEMS sensors for force and displacement measurement.</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Fluid Mechanics: development of mathematical fluid models for the study of of new materials, modern production and transport means; study of nonlinear waves in fluids, flows in biofluids and microfluidic flows; theory and practice of complex systems: complex fluid, social and other complex systems in the field of natural sciences and biology and nanocomposite materials.</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Mechanics of Deformable Solids: the mechanical behavior of various materials (metals, metallic and non-metallic composites, ceramics, biological tissues) subjected to mechanical impacts is studied; non-destructive testing of materials and constructions based on laser-optical, ultrasonic, electromagnetic and acoustic-emission methods.</p>\r\n</li>\r\n</ul>\r\n<ul style=\"text-align: justify;\">\r\n \t<li>\r\n<p align=\"justify\">Biomechanics: biodynamics, biorheology and biomechanics of environments and processes - study of the mechanical and electrical properties of blood and the formed elements of blood in the conditions of stationary and non-stationary flow. Disorders in hemorheology and hemodynamics by cerebrovascular diseases, macro- and microcirculation, and peripheral circulation in patients with type 2 diabetes mellitus are analyzed. Mathematical modelling and numerical simulations in mechanics: modeling and numerical analysis examination of phenomena and processes of modern micro- and nano-technologies and bio-processes.</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Physico-chemical mechanics: development of new technologies for the preparation of polymeric micro- and nanocomposites created on the basis of polymeric matrices of different origins and methods for their study. Structural and mechanical studies of high-tech silicate systems: modelling of structural, strength-deformation and technological properties of structural silicate systems, self-recovering composites, application of waste products in the composition of silicate composites and optimization of testing machines. Expert activity in the field of special concrete and mortars.</p>\r\n</li>\r\n</ul>\r\n<p style=\"text-align: justify;\" align=\"justify\">The results of the research are reflected in publications in authoritative editions and are presented at a number of international and national scientific forums. IMech researchers work on dozens of scientific themes funded by BAS budget, the Science Fund at the Ministry of Education and Science, the National Innovation Fund and international programs. The achieved applied results are protected by dozens of patents and awarded prestigious awards.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">The Institute maintains experimental equipment and methods for studying different systems:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>\r\n<p align=\"justify\">The equipment in the open laboratory of experimental mechanics which disposes of unique devices for mechanical, thermal and rheological testing of materials is on a world level.</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Robotic devices with rehabilitation and assistive functions (active orthoses, prostheses and exoskeletons) to support and analyze human movements, communication interfaces and virtual reality are designed and developed in the laboratory on rehabilitation robotics and virtual reality experiments.</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Laser-optical methods and experimental equipment for measuring displacements and deformations in solids and liquids by speckle interferometry and digital correlation analysis of images;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Devices for measuring and non-destructive testing of the physical and mechanical properties of materials and structures;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Computer system with viscometer for rheological measurements of physiological liquids;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Laboratory equipment testing materials stretch and stress-relaxation studies;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Equipment for testing the mechanical properties of nanomaterials.</p>\r\n</li>\r\n</ul>\r\n<p style=\"text-align: justify;\" align=\"justify\">There is an educational center for the training of non-destructive control specialists: defectoscopists in the Institute of Mechanics which is part of PhD Training Centre of BAS. It is organized in accordance with the requirements of ISO 25108. The training programs and their requirements are in compliance with the following standards: ISO 25107, BDS EN ISO 9712, EN 4179 and ISO 18436-2.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">The Institute of Mechanics is accredited to teach PhD students under the following PhD programs:</p>\r\n\r\n<ol>\r\n \t<li style=\"text-align: justify;\">Scientific specialty \"Theoretical mechanics\", Professional field: 4. \"Natural sciences, mathematics and informatics\"</li>\r\n \t<li style=\"text-align: justify;\">Scientific specialty \"Applied Mechanics\", Professional Field: 4. \"Natural Sciences, Mathematics and Informatics\"</li>\r\n \t<li style=\"text-align: justify;\">Scientific specialty \"Mechanics of a deformable body\", Professional field: 4. \"Natural sciences, mathematics and informatics\"</li>\r\n \t<li style=\"text-align: justify;\">Scientific specialty \"Fluid Mechanics\", Professional Field: 4. \"Natural Sciences, Mathematics and Informatics\"</li>\r\n \t<li style=\"text-align: justify;\">Scientific specialty \"Biomechanics\", Professional field: 4. \"Natural sciences, mathematics and informatics\"</li>\r\n \t<li style=\"text-align: justify;\">Scientific specialty \u201cMathematical Modelling and Application of Mathematics, Professional Field: 4. \"Natural Sciences, Mathematics and Informatics\"</li>\r\n \t<li style=\"text-align: justify;\">Scientific specialty \"Robots and manipulators\", Professional field: 5. \"Technical sciences\"</li>\r\n \t<li style=\"text-align: justify;\">Scientific specialty \"Composite Materials Technology\", Professional Field: 5.6 \"Materials and Materials Science\".</li>\r\n \t<li style=\"text-align: justify;\">Scientific specialty \"Building materials, products and technologies\u201d</li>\r\n</ol>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]International relations[/fusion_title][fusion_checklist icon=\"fa-random\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n<p class=\"r\"><a href=\"http://iutam.org/\">International Union of Theoretical and Applied Mechanics (IUTAM)</a></p>\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Mechanics","post_link":"https://www.bas.bg/?page_id=24042&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Mechanics\" width=\"300\" height=\"185\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/imech-300x185.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wpml_word_count%":"{\"total\":0,\"to_translate\":{\"bg\":945,\"en\":945}}","%_edit_lock%":"1562506677:18","%_edit_last%":"18","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_fallback_id%":"","%pyre_demo_slider%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg%":"","%pyre_header_bg_id%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_responsive_sidebar_order%":"","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_id%":"","%pyre_page_bg_full%":"default","%pyre_page_bg_repeat%":"default","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_id%":"","%pyre_wide_page_bg_full%":"default","%pyre_wide_page_bg_repeat%":"default","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_font_color%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_retina_id%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"42.6760081","%_wpgmp_metabox_longitude%":"23.370281100000057","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%_wpml_media_duplicate%":"1","%_wpml_media_featured%":"0","%_last_translation_edit_mode%":"native-editor","%acf_bas_deptname%":"Institute of Mechanics","%acf_bas_fax%":"+359 2 979 6451","%acf_bas_email%":"<a href=\"mailto:director@imbm.bas.bg\">director@imbm.bas.bg</a>","%acf_bas_latitude%":"42.6760081","%acf_bas_longtitude%":"23.370281100000057","%_thumbnail_id%":"16350","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"default_sidebar","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"default_sidebar","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624442998","%avada_post_views_count%":"769","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24042,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Mathematics and Informatics","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Mathematics and Informatics\" width=\"300\" height=\"225\" src=\"https://www.bas.bg/wp-content/uploads/2017/02/imi_004-e1489731587362-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Mathematics and Informatics</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 8, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 3828, +359 2 979 3824</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://math.bas.bg\" target=\"_blank\" rel=\"noopener\">http://math.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=23993&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.6750145","lng":"23.368566500000043","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=23993&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 8, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 3828, +359 2 979 3824","%acf_bas_site%":"<a href=\"http://math.bas.bg\" target=\"_blank\" rel=\"noopener\">http://math.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p><img class=\"alignleft\" src=\"/wp-content/uploads/2017/02/imi_logo.png\" alt=\"\" width=\"273\" height=\"248\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Mathematics and Informatics at the Bulgarian Academy of Sciences (IMI-BAS)</strong> is a leading national research center in the field of mathematical sciences, informatics and information technologies.</p><p align=\"justify\">The date 27 October 1947 is rightly considered the birth date of IMI when the Governing Council (GC) of BAS decided to create three mathematical commissions, in the plan for the scientific activity in 1947-1948: for demographic studies, for mathematical studies of the representative method in statistics and for financial mathematical research of state bonds and external bonds guaranteed by the state. This is how the idea of \u200b\u200bcreating the Natural-Mathematical Branch of the Academy for the development of scientific research institutes in different scientific fields - which had been discussed by GC of the Bulgarian Academy of Sciences already in 1945 - began its realization.</p><p align=\"justify\">IMI has results and applied developments at world level, expressed in publications in authoritative printed editions and presented at a number of international and national scientific forums. IMI collaborators publish about 400 scientific articles annually, out of which more than 200 in reputable journals and collections of papers from international conferences.</p><p align=\"justify\">Owing to its high professionalism, IMI is integrated into the world scientific community and enjoys a deserved repute. Every year, the Institute hosts over 200 renowned foreign scientists, organizes over 15 scientific conferences, seminars and schools.</p><h6 align=\"justify\">Research and applied activity</h6><p align=\"justify\">IMI collaborators work on 75 scientific topics funded by BAS budget, by the Science Fund at the Ministry of Education and Science and by international, regional and other programs. The Institute maintains 19 permanent scientific seminars. The library is among the best in Southeast Europe in the field of mathematical sciences.</p><p align=\"justify\">The mission of the Institute consists in:</p><ul><li>Developing fundamental and applied research in mathematics and informatics in line with national and European priorities and integrating IMI into European and global research area.</li><li>Scientific research in the fields of mathematical structures (discrete mathematical structures and applications, differential equations, analysis, geometry and topology), mathematical modelling (stochastic, operation research, numerical methods and scientific calculations, approximation theory and mathematical models) and mathematical informatics (mathematical foundations of informatics, mathematical linguistics and knowledge processing, modelling of software, cognitive and information processes) that enrich the theoretical foundations of mathematics and informatics and lead to innovative applications in other sciences, information and communication technologies, industry and society.</li><li>Application of mathematics and informatics in national educational programs and educational processes at all levels in the country.</li></ul><blockquote><p align=\"justify\">In 1961, the first Bulgarian computing center was created at the Mathematical Institute (MI).</p><p align=\"justify\">In the period 1962-1964, the first Bulgarian digital computerized machine Vitosha was created.</p><p align=\"justify\">In 1965, the first electronic calculator Elka 6521 was created.</p><p align=\"justify\">In the period 1966-1984, a number of institutions that were important for science and practice separated from MI: the Central Institute of Computing (CIC, now \"Business Innovation Center IZOT\"), Institute of Mechanics and Biomechanics at BAS (now Institute of Mechanics), Coordination Center for Informatics and Computing at the Bulgarian Academy of Sciences (now Institute of Information and Communication Technologies).</p><p align=\"justify\">Between 1970 and 1988, the Mathematical Institute was part of the Unified Center for Mathematics and Mechanics (UCMM). Then, for the first time, the model of the three cycle system of university education, which two decades later was adopted throughout Europe, was introduced.</p><p align=\"justify\">Together with the St. St. Cyril and Methodius Foundation, Evrika Foundation and the Union of Bulgarian Mathematicians, in 2000 IMI founded the High School Student Institute of Mathematics and Informatics.</p><p align=\"justify\">In 2006, a National Center for Digitization of Scientific, Cultural and Historical Heritage was set up in IMI.</p></blockquote><p align=\"justify\">World famous scientists such as Acad. L Tchakalov, Acad. N. Obreshkov, Acad. K. Popov, Acad. L. Iliev, Acad. B. Sendov, Acad. B. Bojanov, Acad. S. Dodunekov, corr.-member Y. Tagamlitzki, corr.-member V. Popov and others worked at IMI or at UCMM.</p><h6 align=\"justify\">Educational activity</h6><p><strong>Doctoral programmes:</strong></p><ul><li>Mathematical logic</li><li>Algebra and theory of numbers</li><li>Differential equations</li><li>Computational mathematics</li><li>Geometry and topology</li><li>Mathematical analysis</li><li>Probability theory and mathematical statistics</li><li>Operations research</li><li>Mathematical modelling and application of mathematics</li><li>Informatics</li><li>Methodology of education in mathematics, informatics and information technologies</li></ul><p><strong>Joint Masters Programs:</strong></p><ul><li>Managing IT projects - in cooperation with NBU</li><li>Financial and accounting management and insuring - jointly with NBU</li><li>Applied statistics - jointly with NBU</li><li>Digital technologies in the creative and recreational industries - jointly with UNIBIT</li></ul><p><strong>Activities with students and young talents with the participation of IMI:</strong></p><ul><li>High School Student Institute of Mathematics and Informatics</li><li>Preparation of the national teams in mathematics, informatics and linguistics for international olympiads and competitions</li><li>Chernorizec Hrabar Tournament: autumn school tournament for 2-12 grade</li><li>Ivan Salabashev Tournament: mathematical tournament for 2-12 grade</li></ul>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"15px\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]<a href=\"http://www.mathunion.org/\">International Mathematicsl Union (IMU) -\u00a0Committee for Mathematics</a>[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://ecmiindmath.org/\">European Consorcium for Mathematics in Industry (ECMI)</a>\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Mathematics and Informatics","post_link":"https://www.bas.bg/?page_id=23993&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Mathematics and Informatics\" width=\"300\" height=\"225\" src=\"https://www.bas.bg/wp-content/uploads/2017/02/imi_004-e1489731587362-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wpml_word_count%":"{\"total\":0,\"to_translate\":{\"bg\":2,\"en\":2}}","%_edit_lock%":"1562582923:18","%_edit_last%":"18","%_wp_page_template%":"100-width.php","%pyre_displayed_menu%":"default","%pyre_display_copyright%":"default","%pyre_display_footer%":"default","%pyre_display_header%":"yes","%pyre_elasticslider%":"0","%pyre_fallback%":"","%pyre_header_bg%":"","%pyre_header_bg_color%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_hundredp_padding%":"","%pyre_main_bottom_padding%":"","%pyre_main_top_padding%":"","%pyre_page_bg%":"","%pyre_page_bg_color%":"","%pyre_page_bg_full%":"default","%pyre_page_bg_layout%":"default","%pyre_page_bg_repeat%":"default","%pyre_page_title%":"default","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bg_parallax%":"default","%pyre_page_title_custom_subheader%":"","%pyre_page_title_text%":"default","%pyre_revslider%":"0","%pyre_show_first_featured_image%":"no","%pyre_sidebar_position%":"default","%pyre_slider%":"0","%pyre_slider_position%":"default","%pyre_slider_type%":"no","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg_full%":"default","%pyre_wide_page_bg_repeat%":"default","%pyre_wooslider%":"","%pyre_avada_rev_styles%":"default","%pyre_footer_100_width%":"default","%pyre_header_100_width%":"default","%pyre_page_title_100_width%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text_alignment%":"default","%pyre_header_bg_opacity%":"","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_borders_color%":"","%fusion_builder_status%":"active","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_last_translation_edit_mode%":"native-editor","%pyre_fallback_id%":"","%pyre_demo_slider%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_custom_text%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"42.6750145","%_wpgmp_metabox_longitude%":"23.368566500000043","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"16025","%acf_bas_deptname%":"Institute of Mathematics and Informatics","%acf_bas_fax%":"+359 2 971 3649","%acf_bas_email%":"<a href=\"mailto:office@math.bas.bg\">office@math.bas.bg</a>, <a href=\"mailto:office@math.bas.bg\">director@math.bas.bg</a>","%acf_bas_latitude%":"42.6750145","%acf_bas_longtitude%":"23.368566500000043","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"default_sidebar","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"display_header":"yes","elasticslider":"0","header_bg_full":"no","header_bg_repeat":"repeat","revslider":"0","show_first_featured_image":"yes","slider":"0","slider_type":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"default_sidebar","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624442994","%avada_post_views_count%":"937","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":23993,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Electrochemistry and Energy Systems","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Electrochemistry and Energy Systems\" width=\"300\" height=\"199\" src=\"https://www.bas.bg/wp-content/uploads/2018/02/IEES_view-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Electrochemistry and Energy Systems</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 10, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 27 55, +359 2 872 25 43</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"https://iees.bas.bg\" target=\"_blank\" rel=\"noopener\">https://iees.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24144&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","address":"\u0418\u043d\u0441\u0442\u0438\u0442\u0443\u0442 \u043f\u043e \u0435\u043b\u0435\u043a\u0442\u0440\u043e\u0445\u0438\u043c\u0438\u044f \u0438 \u0435\u043d\u0435\u0440\u0433\u0438\u0439\u043d\u0438 \u0441\u0438\u0441\u0442\u0435\u043c\u0438 \u043a\u044a\u043c \u0411\u0410\u041d, \u0421\u043e\u0444\u0438\u044f, \u0411\u044a\u043b\u0433\u0430\u0440\u0438\u044f","location":{"lat":"42.6760393","lng":"23.367099499999995","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24144&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 10, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 27 55, +359 2 872 25 43","%acf_bas_site%":"<a href=\"https://iees.bas.bg\" target=\"_blank\" rel=\"noopener\">https://iees.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><a href=\"https://www.bas.bg/wp-content/uploads/2018/02/IEES-BG.jpg\"><img class=\"alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2018/02/IEES-BG-300x193.jpg\" alt=\"\" width=\"300\" height=\"193\" /></a>[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]T[/fusion_dropcap]he mission of the <strong>Institute of Electrochemistry and Energy Systems</strong> is to build, develop and preserve scientific knowledge as regards the production, industrial application and operational know-how of efficient advanced technologies implemented in electrochemical energy systems and the training of highly specialized staff as highly capable experts and consultants at the national and international level. For more than five decades, scientific research activities are being carried out at IEES in the field of fundamental and applied electrochemistry, that are currently structured into four thematic subject areas:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Batteries. Research and development aimed at creating novel kinds of rechargeable batteries \u2013 lead acid, lithium, metallic, superconductors for energy storage and for powering hybrid and electric vehicles.</li>\r\n \t<li>Hydrogen and fuel cells. Research in the field of hydrogen energy systems \u2013 the development and improvement of technologies for electrochemical production, storage and transformation into \"green\" hydrogen, development of fuel and reversible cells; the design of prototypes of hydrogen energy systems.</li>\r\n \t<li>Energy materials. Development and testing of new materials (catalysts, catalytic supports, electrodes, electrolytes, additives, inhibitors) for use in various electrochemical systems (batteries, fuel cells, electrochemical sensors, etc.); studies of processes, mechanisms and phenomena of novel knowledge acquisition in the energy materials subject field.</li>\r\n \t<li>Theoretical electrochemistry and electrochemical methods. The development and introduction of modern electrochemical methods, techniques, tools and technologies for characterization, testing, monitoring and diagnostics of different electrochemical systems; the training of specialists, doctoral and post-doctoral students.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The IEES implements projects funded by the National Science Fund, the National Innovation Fund, European Framework Programs, NATO, UNESCO, the Advanced Lead Acid Battery Consortium (ALABC) and other international organizations; cooperates with companies from the country and abroad and performs specifically assigned tasks in the applied sciences field.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Some more significant achievements</h6>\r\n<ul style=\"text-align: justify;\">\r\n \t<li>A powerful package of electrochemical techniques has been developed to characterize and test electrochemical energy sources by combining a series of specially developed high-sensitivity and selective instrumental methods (Non-stationary Impedance, Differential Impedance Analysis, Differential Coulometric Spectroscopy);</li>\r\n \t<li>Inhibitors have been found for the sulphation of lead-carbon electrodes for lead-acid batteries operating in partially charged and partially discharged state;</li>\r\n \t<li>Technology for the production of a three-layer separator with innovative design for use in modern types of lead-acid stationary batteries has been developed in order to extend their lifetime;</li>\r\n \t<li>A system for intelligent management and control of the operation of a composite rechargeable battery in an electric vehicle has been developed;</li>\r\n \t<li>A Ni / Zn battery prototype has been developed for stationary energy storage;</li>\r\n \t<li>Technology for membrane electrode assembly (MEA) for fuel and electrolytic cells with polymeric anion-conducting membrane has been developed;</li>\r\n \t<li>Dual membrane solid-oxide fuel cell has been developed with an innovative design that eliminates the principal drawback of fuel cells and electrolyzers related to the separation or injection of water through the electrode by introducing a separate water chamber. Its unique advantages are the ability to work in high efficiency mode in combination with quick (instant) switching;</li>\r\n \t<li>Reliable predictive models for assessing long-term performance and probability of damage to solid-oxide fuel cells are in the process of being developed;</li>\r\n \t<li>Research on the creation of a bifunctional gas-diffusion electrode for new types of rechargeable metal-air batteries continues;</li>\r\n \t<li>Work on creating hybrid supercapacitors for use in electric vehicles</li>\r\n</ul>\r\n<h6 style=\"text-align: justify;\">Outstanding science-applied developments and their implementation in production</h6>\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Starter lead batteries with a plastic box, replacing the ebonite construction - \"Start\" plant, Tolbuhin city (today Dobrich);</li>\r\n \t<li>Lithium-manganese dioxide (Li/MnO2) and lithium-sulfur dioxide (Li/SO2) elements and batteries - Musala plant, Samokov town;</li>\r\n \t<li>Zinc-air batteries designed for special purpose applications, at different levels of humidity - Musala plant, Samokov;</li>\r\n \t<li>Catalytic method and device for purification of sulfur dioxide from waste gases in a pilot installation \u2013 Copper production plant in Pirdop;</li>\r\n \t<li>Special purpose batteries type \"Stirchell\", \"Osa\" and \"Tintyava\";</li>\r\n \t<li>Quaternary sulfate paste to prolong the lifetime of positive plates in lead batteries - \"VARTA\", Germany;</li>\r\n \t<li>Wet-filling of tubular plates to improve the energy performance of lead panzer batteries and prolong their lifetime - Energia Targovishte, Elhim-Iskra, Pazardzhik and \u201cHBL Power Systems\u201d, India.</li>\r\n</ul>\r\n<blockquote>\r\n<p style=\"text-align: justify;\"><strong>Impressive moments in the history of the IEES</strong></p>\r\n<p style=\"text-align: justify;\">1970 - With a primary zinc-air battery, IEES tested a demonstration electromobile ELMO 70, based on Moskvich 428, which first travelled 210 km - six months before the General Motors prototype.\r\n1977 - Together with specialists from CNRS, France, for the first time using the electrochemical impedance spectroscopy method, \"battery impedance\" was measured - which had been previously considered unachievable by this method.\r\n1984 - the first Bulgarian expedition to climb Mount Everest in the Himalayas was successfully equipped with Zinc-air and lithium-sulfur dioxide batteries, created in IEES (CLEPS).\r\n1997 - In a co-operation with the German company ChemTek, a world record at a Salt Lake City /USA/ race was achieved: with a single charge, the demonstration electric van with a rechargeable zinc-air battery passed 764 km for 27 hours without interruption at ambient temperature 0\u00b0 C in the night / 10 \u00b0 C in the day.\r\n2003 - With a project in EU FP6, IEES received the status of Center of Excellence in Portable and Emergency Energy Sources (POEMES) and implemented a program to increase, systemize and disseminate knowledge on the sources of energy and develop e-science - an electronic form for the dissemination of knowledge in the field.\r\n2018 - IEES, in a consortium with another 11 institutes of the Bulgarian Academy of Sciences and teams from TU-Sofia and Sofia University, won a project for the construction of a Center of Excellence \u201cMechatronica and clean technologies\u201d, under OP Science and Education for Smart Growth.</p>\r\n</blockquote>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]International relations[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]<p><a href=\"https://ise-online.org/\" target=\"_blank\" rel=\"noopener noreferrer\">International Society of Electrochemistry (ISE)</a></p>[/fusion_li_item][fusion_li_item icon=\"\"]<p><a href=\"https://fch.europa.eu/\" target=\"_blank\" rel=\"noopener noreferrer\">Fuel Cells and Hydrogen Joint Undertaking (FCH JU)</a></p>[/fusion_li_item][fusion_li_item icon=\"\"]<p><a href=\"https://www.eera-set.eu/\" target=\"_blank\" rel=\"noopener noreferrer\">European Energy Research Alliance (EERA)</a></p>[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Electrochemistry and Energy Systems","post_link":"https://www.bas.bg/?page_id=24144&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Electrochemistry and Energy Systems\" width=\"300\" height=\"199\" src=\"https://www.bas.bg/wp-content/uploads/2018/02/IEES_view-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"\u0418\u043d\u0441\u0442\u0438\u0442\u0443\u0442 \u043f\u043e \u0435\u043b\u0435\u043a\u0442\u0440\u043e\u0445\u0438\u043c\u0438\u044f \u0438 \u0435\u043d\u0435\u0440\u0433\u0438\u0439\u043d\u0438 \u0441\u0438\u0441\u0442\u0435\u043c\u0438 \u043a\u044a\u043c \u0411\u0410\u041d, \u0421\u043e\u0444\u0438\u044f, \u0411\u044a\u043b\u0433\u0430\u0440\u0438\u044f","%_wpgmp_metabox_latitude%":"42.6760393","%_wpgmp_metabox_longitude%":"23.367099499999995","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Electrochemistry and Energy Systems","%acf_bas_fax%":"+359 2 872 25 44","%acf_bas_email%":"<a href=\"mailto:iees@iees.bas.bg\">iees@iees.bas.bg</a>","%acf_bas_latitude%":"42.6760393","%acf_bas_longtitude%":"23.367099499999995","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_oembed_7509afed69a0f3e926f0e00f0cf7863e%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"https://www.eera-set.eu/","%_gallery_link_target%":"_blank","%_wpml_word_count%":"{\"total\":959,\"to_translate\":{\"en\":959}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"1","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17429","%_edit_lock%":"1562594094:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443010","%avada_post_views_count%":"626","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24144,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Botanical Garden of BAS","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Botanical Garden of BAS\" width=\"300\" height=\"225\" src=\"https://www.bas.bg/wp-content/uploads/2018/01/F-1.-Za-Gradina-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Botanical Garden of BAS</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 22 Okolovrasten Pat Str., Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 967 11 05</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://garden-bas.org/bg/\" target=\"_blank\" rel=\"noopener\">http://garden-bas.org/bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24427&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","address":"\u0411\u043e\u0442\u0430\u043d\u0438\u0447\u0435\u0441\u043a\u0430 \u0433\u0440\u0430\u0434\u0438\u043d\u0430, \u0421\u043e\u0444\u0438\u044f, \u0411\u044a\u043b\u0433\u0430\u0440\u0438\u044f","location":{"lat":"42.64424829999999","lng":"23.29851689999998","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24427&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"22 Okolovrasten Pat Str., Sofia, Bulgaria","%acf_bas_phone%":"+359 2 967 11 05","%acf_bas_site%":"<a href=\"http://garden-bas.org/bg/\" target=\"_blank\" rel=\"noopener\">http://garden-bas.org/bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><a href=\"https://www.bas.bg/wp-content/uploads/2018/01/F-1.-Za-Gradina.jpg\"><img class=\"alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2018/01/F-1.-Za-Gradina-300x225.jpg\" alt=\"\" width=\"300\" height=\"225\" /></a>[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Botanical garden of the Bulgarian Academy of Sciences</strong> is a specialized unit with an object of activity to support documented scientific collections of living plants for the needs of education and experimental botany. The public function of the Garden is related to the issues of exploration and conservation of biodiversity and the dissemination of knowledge about it among the broadest public strata, with a view to building a relationship to the sustainable management of biodiversity.</p>\r\n\r\n<blockquote>\r\n<p style=\"text-align: justify;\">The Botanical Garden of the Bulgarian Academy of Sciences maintains the richest collection of plants in our country. Over 1% of the variety of higher plants in the world is included in its collections.</p>\r\n</blockquote>\r\n<p style=\"text-align: justify;\">The garden is a base for practical classes of students and pupils. In relation to the obligations of the country under the international Convention on Trade in Endangered Species of Wild Fauna and Flora of the United Nations (CITES), a Rescue Center for Confiscated Plants has been established. Materials for research and horticultural purposes are exchanged with over 450 gardens and arboreta from 62 countries; we provide plants to enrich the collections of other gardens and parks in the country. Garden Specialists have a leading role in defining the Network of Important Plant Areas in Bulgaria, actively participating in the Red List of Plants in Bulgaria and Europe, the National System for Monitoring of Higher Plants.</p>\r\n\r\n<h6 style=\"text-align: justify;\">History</h6>\r\n<p style=\"text-align: justify;\">The beginning of building the institution and the collections was more than a century ago, with the building of the Royal Botanical Garden in Sofia, located between the present boulevards \"Tsar Osvoboditel\", \"Levski\" and \"Bulgaria\". Since 1947, this Garden, with the preserved collections, has become part of the Botany Institute with Botanical Garden. In connection with the construction of the Monument of the Soviet Army, the Garden was moved twice, having its present place at the foot of Vitosha Mountain since 1969.</p>\r\n<p style=\"text-align: justify;\">Since 1993, it has been an autonomous specialized unit at the Bulgarian Academy of Sciences. Since 1998, it has been open to visitors.\r\nAs part of the green system of the capital, the Garden, although with unfinished construction, is also a place for relaxation and enjoyment for thousands of visitors. Every year there are thematic events: \"Meetings with plants\", exhibitions for individual groups (azaleas, orchids, begonias) and others. Most popular and visited are the greenhouse collections, followed in the summer by the roses. In spring time, it is the most highly situated part of the Garden with the collection of tree-shrub plants from Asia which is attractive.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational initiatives</h6>\r\n<p style=\"text-align: justify;\">The collections are a basis for the training of students from Sofia University, University of Forestry, New Bulgarian University and Trakia University within their courses in Botany, Ecology, Dendrology and Floriculture, with separate practical exercises.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"]\r\n\r\n[acf field=\"acf_bas_site\"]\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Botanical Garden of BAS","post_link":"https://www.bas.bg/?page_id=24427&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Botanical Garden of BAS\" width=\"300\" height=\"225\" src=\"https://www.bas.bg/wp-content/uploads/2018/01/F-1.-Za-Gradina-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"\u0411\u043e\u0442\u0430\u043d\u0438\u0447\u0435\u0441\u043a\u0430 \u0433\u0440\u0430\u0434\u0438\u043d\u0430, \u0421\u043e\u0444\u0438\u044f, \u0411\u044a\u043b\u0433\u0430\u0440\u0438\u044f","%_wpgmp_metabox_latitude%":"42.64424829999999","%_wpgmp_metabox_longitude%":"23.29851689999998","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"9\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Botanical Garden of BAS","%acf_bas_fax%":"+359 2 967 28 23","%acf_bas_email%":"<a href=\"mailto:bgarden.bas@abv.bg\">bgarden.bas@abv.bg</a>","%acf_bas_latitude%":"42.64424829999999","%acf_bas_longtitude%":"23.29851689999998","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_oembed_7c01b3785f4b38c1256edc8ce0aa61da%":"{{unknown}}","%_oembed_c8db4f9b07b8107aa8cfc5101f8efba1%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://garden-bas.org/bg/","%_gallery_link_target%":"_blank","%_wpml_location_migration_done%":"1","%_oembed_540aae4b67c9ab3c467b7594cf0c5e16%":"{{unknown}}","%_wpml_word_count%":"{\"total\":490,\"to_translate\":{\"en\":490}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"0","%_thumbnail_id%":"17310","%_edit_lock%":"1562934456:18","%_edit_last%":"18","%pyre_demo_slider%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_last_translation_edit_mode%":"native-editor","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443040","%avada_post_views_count%":"496","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24427,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Academic Specialized Unit","id":"9","type":"category"}]},{"source":"post","title":"Institute of Robotics &#8220;Saint Apostle and Gospeller Mathew&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Robotics &#8220;Saint Apostle and Gospeller Mathew&#8221;\" width=\"200\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2018/01/Logo_IR_BAS-200x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Robotics &#8220;Saint Apostle and Gospeller Mathew&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 2, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 870 3361, +359 2 405 3055, +359 2 979 3230</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://ir.bas.bg\" target=\"_blank\" rel=\"noopener\">http://ir.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24053&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","address":"\u0418\u043d\u0441\u0442\u0438\u0442\u0443\u0442 \u041f\u043e \u0420\u043e\u0431\u043e\u0442\u0438\u043a\u0430 \u0411\u0410\u041d, Sofia, Bulgaria","location":{"lat":"42.67643580000001","lng":"23.368469900000036","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24053&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 2, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 870 3361, +359 2 405 3055, +359 2 979 3230","%acf_bas_site%":"<a href=\"http://ir.bas.bg\" target=\"_blank\" rel=\"noopener\">http://ir.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><a href=\"https://www.bas.bg/wp-content/uploads/2018/01/Logo_IR_BAS.jpg\"><img class=\"alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2018/01/Logo_IR_BAS-200x300.jpg\" alt=\"\" width=\"200\" height=\"300\" /></a>[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Robotics \"St. Ap. and Gospeller Matthew\"(IR - BAS)</strong>, as a leading national scientific institution integrated in the European Research Area, conducts complex fundamental and engineering studies leading to innovative technologies and inventions, trains doctoral students from Bulgaria and abroad as well as highly qualified specialists and Master students in robotics, sensorics, mechatronics and artificial intelligence systems.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">With its developments, expertise and project activities, IR-BAS is in favor of society and is a sought-after partner mainly by the national industry, consulting in these avant-garde areas state and non-governmental organizations, companies and enterprises. The institute disseminates knowledge and skills in robotics, mechatronics and sensorics at secondary schools through the RoboAcademy for young talents founded by it. The IR is among the initiators to extend the scope of application of robotics and artificial intelligence to public relations before the European Parliament, through the European Robotics Agency.</p>\r\n\r\n<h6 style=\"text-align: justify;\" align=\"justify\">Priorities of the IR \u2013 BAS</h6>\r\n<p style=\"text-align: justify;\" align=\"justify\">The leading research of the Institute is constantly evolving and enriching in line with world trends and achievements in robotics, which is currently the most dynamically developing field of science and technology. According to the EU, US, Russia and Japan Strategic Perspectives, by 2040, 47% of the industry in the world will be robotic.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">The current priorities of the IR-BAS, adopted by the Scientific Council, include:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>\r\n<p align=\"justify\">Industrial and service robotics with multiprofile applicability;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Sensors, Hall Elements, Micro- and Nano-Converters and Components including Intelligent Multisensors for Robotics, Mechatronics, Non-Contact Automatics, Intelligent Process and Production Management, etc .;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">3D design and printing for robots and manipulators, training and development of the educational skills of children and students through robots and cognitive methods;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Medical and interactive robotics, management of cyber-physical, robotic and mechatronic platforms, including through intercepting and processing human brain signals;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Robots, mechatronic systems, intelligent interfaces and quantum communication for counterterrorism, security and defense purposes, including underwater, ground and air combat robots and platforms;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Robotic and mechatronic biotechnology and energy systems;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Specialized and unique measurement methods and instruments, metrological provision in sensors, robotics and mechatronics, etc.</p>\r\n</li>\r\n</ul>\r\n<blockquote>\r\n<p style=\"text-align: justify;\" align=\"justify\">The Institute a national leader in recognized patents with over 150 inventions. For the most part, they are transferred as technologies to companies and businesses that have made a significant economic contribution through them.</p>\r\n</blockquote>\r\n<p style=\"text-align: justify;\" align=\"justify\">Some of the key achievements of the IR-BAS include:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>\r\n<p align=\"justify\">Development of cyber-physical systems in the field of robotics for the training of talented students and to support the social inclusion of adults and children with special needs;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">New fundamental surface properties laws have been discovered, in more than 20 inventions of 2D and 3D sensor systems and devices for robotics, mechatronics and contactless automatics;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">A family of industrial and service robotic platforms with increased technical and performance characteristics and dual purpose based on 9 inventions;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Robotic power systems for transforming the energy of sea waves into electrical, including 5 inventions, etc.</p>\r\n</li>\r\n</ul>\r\n<p style=\"text-align: justify;\" align=\"justify\">The creative activity is concentrated in 7 thematically related laboratories equipped with modern control-measuring technologies and experimental methods, including next- generation atomic-force microscope for study of sensor structures to sense a surface. The prototypes of robotic systems are experimented on the basis of NAO-type robots.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">A direction in which science and technology-relevant results are planned in the near future is the remote sensing control of bio-systems by intercepting human brain signals.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">IR-BAS has subsidiaries in Plovdiv, Veliko Tarnovo and Malko Tarnovo, extending the scope of research and applied activities in robotics, sensorics and mechatronics on a national scale. Participation in Regional Academic Centres is also active, mainly in Pleven, Plovdiv and Rousse.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">IR-BAS was accredited in 2017 by the National Evaluation and Accreditation Agency to train PhD students in 4 specialties in the field of Sensorics, Robotics and Mechatronics, Cybernetics and Automation of Production by conducting 6 doctoral programmes. Trained PhD students are more than 20, and Master students - more than 10. The Institute has one of the largest and best-kept technical libraries in the country with more than 56 300 information units.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">There are general institutional and thematic sectoral seminars on topical issues of robotics, sensorics and cybernetic systems at IR-BAS. The Institute is the organizer of the prestigious international conference \"Mechatronics and Robotics\", which has been held for more than 30 years.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]International relations[/fusion_title][fusion_checklist icon=\"fa-random\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\nIFAC\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nEurosensors\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nNATO Sci. Council\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nIEEE\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nCEPIS\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Robotics &#8220;Saint Apostle and Gospeller Mathew&#8221;","post_link":"https://www.bas.bg/?page_id=24053&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Robotics &#8220;Saint Apostle and Gospeller Mathew&#8221;\" width=\"200\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2018/01/Logo_IR_BAS-200x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_bd7b449fa14f712169bdeee575e28872%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://ir.bas.bg","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"\u0418\u043d\u0441\u0442\u0438\u0442\u0443\u0442 \u041f\u043e \u0420\u043e\u0431\u043e\u0442\u0438\u043a\u0430 \u0411\u0410\u041d, Sofia, Bulgaria","%_wpgmp_metabox_latitude%":"42.67643580000001","%_wpgmp_metabox_longitude%":"23.368469900000036","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Robotics \"Saint Apostle and Gospeller Mathew\"","%acf_bas_fax%":"+359 2 405 3061 ","%acf_bas_email%":"<a href=\"mailto:office@ir.bas.bg\">office@ir.bas.bg</a>","%acf_bas_latitude%":"42.67643580000001","%acf_bas_longtitude%":"23.368469900000036","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_word_count%":"{\"total\":766,\"to_translate\":{\"en\":766}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"1","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17295","%_edit_lock%":"1562507388:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624442998","%avada_post_views_count%":"499","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24053,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Laboratory of Telematics","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Laboratory of Telematics\" width=\"197\" height=\"188\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/logo-1.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Laboratory of Telematics</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 8, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 873 2619</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.cc.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.cc.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24070&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.675251","lng":"23.368371","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24070&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 8, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 873 2619","%acf_bas_site%":"<a href=\"http://www.cc.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.cc.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><a href=\"/wp-content/uploads/2017/12/logo-1.jpg\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/12/logo-1.jpg\" alt=\"\" width=\"197\" height=\"188\" /></a>[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]T[/fusion_dropcap]he mission of the <strong>Laboratory of Telematics</strong> at the Bulgarian Academy of Sciences is to enhance the ICT skills of information society users in Bulgaria.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">Research and development in the field of education, computer and communication technologies, health, national security and defense, the preservation of cultural and historical identity and heritage are carried out in the Laboratory, on the road to building a knowledge-based economy and society.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">Training programs in the field of computer and communication technologies are developed using Microsoft technologies and solutions;</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">Work is being done to create prerequisites for the implementation of the developments developed in the educational process at all levels in the Academy and in the country, as well as to develop a training center for language, computer and communication technologies with the application of Microsoft technologies and solutions.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">The unit is the successor to the first electronic computing center in Bulgaria.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]Contacts[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]International relations[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]<a href=\"http://www.sai.bg/\" target=\"_blank\" rel=\"noopener noreferrer\">The John Atanasoff Society of Automatics and Informatics (SAI)</a>[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Laboratory of Telematics","post_link":"https://www.bas.bg/?page_id=24070&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Laboratory of Telematics\" width=\"197\" height=\"188\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/logo-1.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_wpmf_gallery_custom_image_link%":"http://www.cc.bas.bg","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.675251","%_wpgmp_metabox_longitude%":"23.368371","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"9\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Laboratory of Telematics","%acf_bas_fax%":"+359 2 873 2619","%acf_bas_email%":"<a href=\"mailto:office@cc.bas.bg\">office@cc.bas.bg</a>","%acf_bas_latitude%":"42.675251","%acf_bas_longtitude%":"23.368371","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_oembed_829c9794a2428747f587ffb94890ed91%":"{{unknown}}","%_oembed_57d3a3dcdf1f830a1f9382361030ad7f%":"{{unknown}}","%_wpml_word_count%":"{\"total\":203,\"to_translate\":{\"en\":203}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"1","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17188","%_edit_lock%":"1562509318:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443002","%avada_post_views_count%":"440","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24070,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Academic Specialized Unit","id":"9","type":"category"}]},{"source":"post","title":"Institute of Biodiversity and Ecosystem Research","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Biodiversity and Ecosystem Research\" width=\"300\" height=\"215\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/Fig_01_logo_bg-300x215.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Biodiversity and Ecosystem Research</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 2 Mayor Yuriy Gagarin Str.,\u00a01113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 873 6137</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.iber.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.iber.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24400&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.677010","lng":"23.354334","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24400&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"2 Mayor Yuriy Gagarin Str.,\u00a01113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 873 6137","%acf_bas_site%":"<a href=\"http://www.iber.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.iber.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/12/Fig_01_logo_bg-300x215.jpg\" alt=\"\" width=\"300\" height=\"215\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Biodiversity and Ecosystem Research (IBER)</strong> conducts research on the theoretical and applied aspects of ecology, biodiversity, environmental protection and sustainable use of biological resources. IBER was established on July 1, 2010 as a successor to three units of BAS: Institute of Botany, Institute of Zoology and Central Laboratory of General Ecology.</p>\r\n<p style=\"text-align: justify;\">The Institute is a major scientific center in Bulgaria in the fields of botany, mycology, zoology, ecology, hydrobiology, parasitology, conservation biology, genetics of the environment, evolutionary biology and other related scientific fields. It provides scientific information, provides methodological assistance to state institutions and civil society structures and presents the country in the European Research Area in the areas of its competence.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">Priority directions in the scientific activities of IBER are:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Studying the structure and functioning of the evolution of organism world, biotic communities, ecosystems and landscapes;</li>\r\n \t<li>Conservation of living nature, approaches and methods for sustainable management of protected natural sites and biological resources;</li>\r\n \t<li>Studying the ecology and biology of economically and socially significant species;</li>\r\n \t<li>Assessment of environmental risk, environmental quality and impacts on it;</li>\r\n \t<li>Developing approaches and methods for biodiversity assessment, bio-monitoring and biosafety systems.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The most important scientific achievements and results of the Institute's work:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Inventory, classification and conservation of biological diversity, and over the last 5 years the scientists from IBER have described more than 90 new species of science (mushrooms, higher plants, invertebrates and vertebrates);</li>\r\n \t<li>Studying rare and endangered species and their habitats; distribution and conservation of medicinal plants and use of their biologically active substances;</li>\r\n \t<li>Assessment of the main factors for loss of biodiversity in the context of global change: habitat fragmentation, environmental pollution, invasive species;</li>\r\n \t<li>Monitoring and assessment of environmental changes: development of methodologies for assessment, classification and improvement of ecosystem status, use of indicator species, development and implementation of bio-analysis and environmental assessment indices;</li>\r\n \t<li>assessments of the conservation status of species and natural habitats: development of expert opinions and opinions, management plans for protected areas, nature reserves and national parks; extension of the NATURA 2000 protected area system;</li>\r\n \t<li>Mapping and assessment of the state of ecosystems (land, freshwater and marine) and ecosystem services.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">Over the last 5 years, IBER has been implementing projects under programmes of the European Commission (23), the European Economic Area (7), the US National Science Foundation, USA (1), other foreign science funds (22), the MOEW (17), other state institutions (6) and companies (14).\r\nIBER maintains the largest and most representative herbarium on the flora of Bulgaria and the Balkan Peninsula, the only one of its kind in Bulgaria mycological (SOMF) and paleobotanical collections and one of the richest zoological collections in Bulgaria.</p>\r\n<p style=\"text-align: justify;\">The Institute disposes of 7 field stations to conduct scientific research in natural conditions (Sreburna, Kalimok, Atanasovsko Lake, Beglika, Plana, Parangalitsa and Sozopol) and renovated laboratories (molecular, chemical, light-microscopy laboratory, chromatographic analysis, ultrastructure and histology, cytogenetic, GIS-center).</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">The institute is accredited for postgraduate training under the following programs:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>ecology and ecosystem protection;</li>\r\n \t<li>botany;</li>\r\n \t<li>zoology;</li>\r\n \t<li>mycology;</li>\r\n \t<li>hydrobiology;</li>\r\n \t<li>parasitology and helminthology;</li>\r\n \t<li>genetics.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The Institute runs schools, led by Assoc. Prof. Dr. Boris Nikolov, for pupils and young nature-lovers at the Bulgarian Ornithological Center. The course \u201cIntroduction to basic methods for ecological research in ornithology\u201d is being held at Biological Experimental Base \"Kalimok\".</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title margin_top=\"\" margin_bottom=\"15px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"3\" content_align=\"left\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\n\u0427\u0435\u0440\u0432\u0435\u043d\u0430 \u043a\u043d\u0438\u0433\u0430 \u043d\u0430 \u0420\u0435\u043f\u0443\u0431\u043b\u0438\u043a\u0430 \u0411\u044a\u043b\u0433\u0430\u0440\u0438\u044f\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><a href=\"https://www.bas.bg/wp-content/uploads/2017/12/Chervena_kniga_na_RB.jpg\"><img class=\"wp-image-8176 size-full aligncenter\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/Chervena_kniga_na_RB.jpg\" alt=\"\" width=\"625\" height=\"450\" /></a></p>\r\n<p style=\"text-align: justify;\">\"Red Data Book of the Republic of Bulgaria\" (2015) - second updated and completed edition in three volumes. The publication is available online at <a href=\"http://e-ecodb.bas.bg/rdb/bg/\" target=\"_blank\" rel=\"noopener noreferrer\">http://e-ecodb.bas.bg/rdb/bg/</a>.</p>\r\n<p style=\"text-align: justify;\">The development is realized on the basis of 10 years of work of over 200 scientists and specialists from IBER, NMNHS, Sofia University \"St. Kliment Ohridski\", \"Paisii Hilendarski\" University of Plovdiv, as well as by a number of NGOs and companies in the country.</p>\r\n<p style=\"text-align: justify;\">In three volumes are presented 808 species of plants and mushrooms, 287 animals and 166 natural habitats.</p>\r\n[/fusion_text][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]<a href=\"https://www.cetaf.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Consortium of European Taxonomic Facilities (CETAF)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://www.esenias.org/\" target=\"_blank\" rel=\"noopener noreferrer\">East and South European Network for Invasive Alien Species (ESENIAS)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://esenias.org/index.php?option=com_content&amp;task=view&amp;id=365\" target=\"_blank\" rel=\"noopener noreferrer\">Danube Region Invasive Alien Species Network (DIAS)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"https://lternet.edu/\" target=\"_blank\" rel=\"noopener noreferrer\">Long Term Ecological Research (LTER)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"https://www.es-partnership.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Ecosystem Services Partnership (ESP)</a>[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Biodiversity and Ecosystem Research","post_link":"https://www.bas.bg/?page_id=24400&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Biodiversity and Ecosystem Research\" width=\"300\" height=\"215\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/Fig_01_logo_bg-300x215.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_dc4520b8c1083100ce7668d892344cab%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://e-ecodb.bas.bg/rdb/bg/","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.677010","%_wpgmp_metabox_longitude%":"23.354334","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Biodiversity and Ecosystem Research","%acf_bas_fax%":"+359 2 870 5498","%acf_bas_email%":"<a href=\"mailto:iber@iber.bas.bg\">iber@iber.bas.bg</a>","%acf_bas_latitude%":"42.677010","%acf_bas_longtitude%":"23.354334","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_word_count%":"{\"total\":732,\"to_translate\":{\"en\":732}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17142","%_edit_lock%":"1562928394:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443036","%avada_post_views_count%":"705","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24400,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute for Nuclear Research and Nuclear Energy","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for Nuclear Research and Nuclear Energy\" width=\"300\" height=\"217\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/\u041b\u043e\u0433\u043e-\u043d\u0430-\u0418\u042f\u0418\u042f\u0415-300x217.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute for Nuclear Research and Nuclear Energy</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 72 Tsarigradsko shosse Blvd., 1784 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 974 37 61 </div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.inrne.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.inrne.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24137&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.6526022","lng":"23.38864269999999","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24137&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"72 Tsarigradsko shosse Blvd., 1784 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 974 37 61 ","%acf_bas_site%":"<a href=\"http://www.inrne.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.inrne.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\" align=\"justify\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/12/\u041b\u043e\u0433\u043e-\u043d\u0430-\u0418\u042f\u0418\u042f\u0415-300x217.jpg\" alt=\"\" width=\"300\" height=\"217\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute for Nuclear Research and Nuclear Energy (INRNE) </strong>at the Bulgarian Academy of Sciences was founded in 1972 and inherited the major part of the former Physical Institute with Atomic Scientific Experimental Base (FI with ANEM) at the Bulgarian Academy of Sciences.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">INRNE is the largest complex center in Bulgaria for scientific and applied research in the field of nuclear physics and nuclear technologies. Both fundamental scientific problems as well as applied tasks for the implementation of important national programs are developed in it.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">Eminent physicists such as Elizaveta Karamihailova, Rashko Zaycoff, Christo Christov, Jelju Jelev, Ivan Zhelyazkov, Pavel Marcov, Nikifor Kashukeev, Emil Nadjakov, Wenceslaw Andrejtscheff and others have worked in INRNE and trained young professionals. The Institute brings together scientists in theoretical and mathematical physics, nuclear physics, physics of high energy and astrophysics, reactor and neutron physics, monitoring and environmental research. By number of publications and citations, INRNE is among the leading academic organizations in Bulgaria. INRNE has established authority in the international scientific community, owing to many years of experience of scientists, the high quality of scientific results and the active cooperation with leading foreign institutes.</p>\r\n\r\n<h6 style=\"text-align: justify;\" align=\"justify\">Research activity</h6>\r\n<p style=\"text-align: justify;\" align=\"justify\">Traditional scientific areas of the Institute include:</p>\r\n\r\n<ul>\r\n \t<li>Theory of elementary particles, string theory, theory of atomic nuclei, soliton interactions and quantum phenomena</li>\r\n \t<li>Experimental physics of the elementary particles, nuclear reactions, structure of atomic nuclei, cosmic rays and gamma-astrophysics at ultra high energies</li>\r\n \t<li>High Energy Physics</li>\r\n \t<li>Neutron interactions and cross sections, physics of the fission</li>\r\n \t<li>Reactor physics, nuclear energy and nuclear safety and security</li>\r\n \t<li>Dosimetry and radiation safety</li>\r\n \t<li>Monitoring and management of the environment, radioecology</li>\r\n \t<li>Radiochemistry, high precision analyses of substances, development and production of radioactive sources</li>\r\n \t<li>Nuclear and neutron methods for investigations of substances, nuclear instrument design and production</li>\r\n</ul>\r\n<p style=\"text-align: justify;\" align=\"justify\">INRNE seeks to apply scientific excellence to the benefit of society. Close cooperation has been established with colleagues from the Kozloduy NPP. Operational activity on dosimetric control and work with ionizing radiation is carried out.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">In the 1990s, one of INRNE units launched the only radioactive waste repository in the country, thus laying the foundations for solving an important societal problem: radio-ecology. Specialized buildings were built in the area of \u200b\u200bNovi Han village, not far from Sofia, provided with the necessary equipment and methods for disposal of such waste. In 2006, by decision of the Council of Ministers, the Radioactive Waste Repository in Novi Han, reconstructed and modernized in accordance with the internationally accepted standards, was submitted to the State Enterprise \"Radioactive Waste\". Notwithstanding, INRNE continues to maintain active scientific contacts with it and renders the necessary high professional assistance to its activities.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">The construction of the National Cyclotron Center, which started after 2015, is a key infrastructure and research project in the field of nuclear research and nuclear energy. The objectives of this project are: active support for the development of nuclear medicine in Bulgaria and in the countries of the Balkan Peninsula; basic training of both future specialists for Kozloduy NPP as well as for nuclear centers and centers of nuclear medicine; conducting research related to nuclear energy, nuclear physics, radiation protection and nuclear safety; providing radiopharmaceutical preparations for the growing needs in the contemporary treatment of socially significant diseases.</p>\r\n\r\n<blockquote>\r\n<p style=\"text-align: justify;\" align=\"justify\">Since 2005, 13 laboratories in INRNE have had and maintained a QQS certificate under ISO 9001: 2000, ISO 14001: 2004 Quality Management System and ISO 14001: 1996 Environmental Management System Certificate.</p>\r\n</blockquote>\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\" align=\"justify\">INRNE is accredited for PhD program training in:</p>\r\n\r\n<ul>\r\n \t<li>Theoretical and Mathematical Physics</li>\r\n \t<li>Nuclear physics</li>\r\n \t<li>Neutron physics and physics of nuclear reactors, incl. Neutron physics, Nuclear reactor physics and dosimetry, Nuclear physics methods and devices for substance analyses</li>\r\n \t<li>Physics of high energies and elementary particles, physics and particle astrophysics</li>\r\n \t<li>Radiochemistry</li>\r\n \t<li>Nuclear reactors</li>\r\n</ul>\r\n<p style=\"text-align: justify;\" align=\"justify\">INRNE Training Center for Specialized Training holds the license \u0421T reg. \u2116 04692 for carrying out specialized training and issuing licenses for activities with sources of ionizing radiation. The tasks of INRNE Training Center for Specialized Training are defined as:</p>\r\n\r\n<ul>\r\n \t<li>Initial specialized training for qualification in performing sources of ionizing radiation (SIR) activities;</li>\r\n \t<li>Conducting specialized support training for qualification in activities with SIR;</li>\r\n \t<li>Examining by a permanent Qualification Examination Commission appointed by the Director of INRNE;</li>\r\n \t<li>Issuance of certificates of competency for activities with SIR.</li>\r\n</ul>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"20px\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]Basic Environmental Observatory (BEO) Moussala[/fusion_title][fusion_imageframe image_id=\"7980\" style_type=\"none\" stylecolor=\"\" hover_type=\"zoomin\" bordersize=\"0\" bordercolor=\"\" borderradius=\"\" align=\"center\" lightbox=\"yes\" gallery_id=\"\" lightbox_image=\"\" alt=\"\" link=\"\" linktarget=\"_self\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"bas-img-bottommargin\" id=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\"]/wp-content/uploads/2017/12/\u0421\u0433\u0440\u0430\u0434\u0430-\u043d\u0430-\u0431\u0430\u0437\u043e\u0432\u0430-e\u043a\u043e\u043b\u043e\u0433\u0438\u0447\u043d\u0430-o\u0431\u0441\u0435\u0440\u0432\u0430\u0442\u043e\u0440\u0438\u044f-\u041c\u0443\u0441\u0430\u043b\u0430.jpg[/fusion_imageframe][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\">The Basic Environmental Observatory (BEO) Moussala, part of INRNE, is located on the highest peak of the Balkan Peninsula - Moussala (2925.4 m above sea level, 42o18`N, 23o59`E) in Rila Mountain.</p>\r\n<p style=\"text-align: justify;\">The unique geographical location of Moussala peak (it is considered to be in the free troposphere) allows, in addition to traditional cosmic rays research, to carry out studies related to global climate change, transport of cross-border pollution, possible correlations of cosmic ray intensity with atmospheric parameters and more.</p>\r\n<p style=\"text-align: justify;\">In 2016, BEO Moussala was recertified by IQNET for ISO 9001: 2008 and ISO 14001: 2004 standards.</p>\r\n[/fusion_text][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute for Nuclear Research and Nuclear Energy","post_link":"https://www.bas.bg/?page_id=24137&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for Nuclear Research and Nuclear Energy\" width=\"300\" height=\"217\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/\u041b\u043e\u0433\u043e-\u043d\u0430-\u0418\u042f\u0418\u042f\u0415-300x217.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_0269d6864e1555560714b35078cef4ad%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.inrne.bas.bg","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.6526022","%_wpgmp_metabox_longitude%":"23.38864269999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute for Nuclear Research and Nuclear Energy","%acf_bas_fax%":"+359 2 975 36 19 ","%acf_bas_email%":"<a href=\"mailto:inrne@inrne.bas.bg\">inrne@inrne.bas.bg</a>","%acf_bas_latitude%":"42.6526022","%acf_bas_longtitude%":"23.38864269999999","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_word_count%":"{\"total\":875,\"to_translate\":{\"en\":875}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"1","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17127","%_edit_lock%":"1562591055:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443006","%avada_post_views_count%":"1589","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24137,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Polymers","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Polymers\" width=\"300\" height=\"208\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/polimer-logo_-300x208.gif\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Polymers</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 103A, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 870 03 09</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://polymer.bas.bg\" target=\"_blank\" rel=\"noopener\">http://polymer.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24272&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.673570","lng":"23.366853","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24272&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 103A, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 870 03 09","%acf_bas_site%":"<a href=\"http://polymer.bas.bg\" target=\"_blank\" rel=\"noopener\">http://polymer.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/12/polimer-logo_-300x208.gif\" alt=\"\" width=\"300\" height=\"208\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Polymers (IP)</strong> is a research unit in the Nanosciences, New Materials and Technologies division of the Bulgarian Academy of Sciences.</p>\r\n<p style=\"text-align: justify;\">The mission of the Institute of Polymers is to carry out research, innovation and training in the field of polymers and polymer materials that contribute to the development of science and technology and benefit society and the economy.</p>\r\n<p style=\"text-align: justify;\">The history of the institute is linked to section \"Macromolecular Chemistry\" created in 1962 at the Institute of Organic Chemistry. In 1972, the section grew into the Central Laboratory of Polymers (CLAP). As a result of the scientific research at CLAP, a number of new technologies were introduced in industrial production: BADIMOL - supramolecular poly (ethylene oxide), polymer additives for cyan-free application of metal coatings, catalysts for the production of phenolic resins, polymer adhesives, new medical materials and more. From 1 March 1990, CLAP was transformed into Institute of Polymers (IP). IP has expanded its research activities with new fundamental research in the field of ionic and radicular polymerization, in the development of polycondensation methods for the production of polymers. Polymer materials have been developed with special properties for use in medicine and pharmacy, biotechnology and agriculture, machine building, environmental protection, etc.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">The Institute of Polymers conducts research in the following areas:</p>\r\n<p style=\"text-align: justify;\"><strong>New polymers and innovative polymeric (nano) materials and technologies</strong></p>\r\n\r\n<ol style=\"text-align: justify;\">\r\n \t<li>Polymers with diverse macromolecular architecture, topology and functionality through controlled polymerization processes and / or modification of macromolecules;</li>\r\n \t<li>Water colloidal systems of amphiphilic copolymers - formation and stabilization of polymeric aggregates of different structure;</li>\r\n \t<li>Polymer-organic and polymer-inorganic hybrid nanomaterials (nanoparticles, nanofibers);</li>\r\n \t<li>High-tech approaches and equipment for the production of nanostructured fibrous materials through electrospinning, electrospray, centrifugal electrospinning and other advanced technologies.</li>\r\n</ol>\r\n<p style=\"text-align: justify;\"><strong>Polymeric materials used in biomedicine, pharmacy and biotechnology</strong></p>\r\n\r\n<ol style=\"text-align: justify;\">\r\n \t<li>Intelligent systems based on temperature and pH sensitive polymers as carriers of delayed or controlled release drug substances;</li>\r\n \t<li>Electroactive composite materials, such as actuators, sensors and switches;</li>\r\n \t<li>Nano-sized carriers (nanoparticles, nano- and microfibrous materials) of drug substances and biommacromolecules;</li>\r\n \t<li>Hydrogels and cryogels for the integration of drugs, enzymes and cells;</li>\r\n \t<li>Phosphorus-containing biologically active materials - poly (aminophosphonate) and supramolecular polyphosphoesters;</li>\r\n \t<li>New polymeric materials with improved biocompatibility or targeted biological activity.</li>\r\n</ol>\r\n<p style=\"text-align: justify;\"><strong>Polymeric materials for alternative energy sources and polymers from renewable and unconventional resources</strong></p>\r\n\r\n<ol style=\"text-align: justify;\">\r\n \t<li>Polymeric membranes for energy converters</li>\r\n \t<li>Active polymeric layers for organic solar elements</li>\r\n \t<li>\"Green\" synthesis of biodegradable polymers</li>\r\n \t<li>Biodegradable polymer mixtures and nanocomposites</li>\r\n \t<li>Recycling and recovery of polymeric waste</li>\r\n</ol>\r\n<p style=\"text-align: justify;\">Key areas of activity in which results have been or are expected to be achieved in the near future are:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Intelligent copolymer networks and hydrogels reacting to temperature and pH changes of the environment with application as carriers of drug substances;</li>\r\n \t<li>Micro- and nanostructured polymeric materials obtained through electrospinning with application in biomedicine as a new generation of materials for wound healing, drug delivery, regenerative medicine, tissue engineering; in biotechnology and environmental protection;</li>\r\n \t<li>Polymeric nanoscale carriers of genetic material, biological molecules and biologically active substances that are able to overcome cellular barriers and reach target organelles;</li>\r\n \t<li>A water-soluble form of poplar propolis in which all biologically active ingredients are dissolved in water by means of block copolymer micelles in the absence of ethyl alcohol or other organic solvents;</li>\r\n \t<li>Phosphorus-containing compounds having specific properties such as biodegradability, biocompatibility, low toxicity, water solubility, amphiphility, high reactivity and thermal stability;</li>\r\n \t<li>Original methods for modifying phosphorus-containing polymers resulting in the production of polymeric analogs of aminophosphonic acids, as well as glycopoly-phosphoramidates which are characterized by their own biological activity or biopdistinguishable properties.</li>\r\n \t<li>Polymeric membranes based on polybenzimidazole (PBI), designed for fuel cells and electrolyzers, including: proton conducting low and medium temperature membranes; high temperature membranes with an operating temperature of up to 180\u00b0 C; crosslinked and composite membranes containing montmorillonite, graphene oxide and activated carbon; and anion conductive PBI membranes which are characterized by very good mechanical properties and high ion conductivity surpassing those known so far.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The Institute of Polymers staff has expertise to identify, characterize and technologically control polymers, materials and composites based on polymers (qualitative and quantitative analysis, thermal and mechanical properties, molecular-mass characteristics, nanoparticle size, viscosity, rheological parameters, etc.).</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">The Institute of Polymers is accredited to train PhD students in professional field: 4.2 Chemistry, Doctoral Program: Polymers and Polymer Materials.</p>\r\n<p style=\"text-align: justify;\">Scientists from IP hold 5 specialized courses at the PhD School of the Training Center - BAS in division 3: \"Nanosciences, New Materials and Technologies\". Practical training is provided by the Institute for students under project BG051PO001-3.3.07-0002 \"Student Practices\", funded under OP HRD. Lecture courses and schools have been prepared and carried out in implementation of BG051PO001-3.3.06 \u2013 006 and BG051PO001-3.3.06 - 0017 projects, funded under OP HRD (Scheme \"Support for the development of doctoral students, post-doctoral students, postgraduates and young scientists\") as well as under project BG05M2OP001-2.009-0019-C01 / 02.06.2017 financed under OP SESG.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]The Institute of Polymers is co-founder of the Central and East European Polymer Network[/fusion_li_item][fusion_li_item icon=\"\"]Prof. Dr. Nevena Manolova is Chairman of the Bulgarian Polymer Society and is represented in the European Polymer Federation and member of the National Committee of the International Union of Pure and Applied Chemistry (IUPAC) and national representative in the Polymer Division of the International Union of Pure and Applied Chemistry IUPAC)[/fusion_li_item][fusion_li_item icon=\"\"]Prof. Stanislav Rangelov is a member of the National Committee of the International Union of Pure and Applied Chemistry (IUPAC)[/fusion_li_item][fusion_li_item icon=\"\"]Assoc. Prof. Dr. Olya Stoilova is a member of the Working Group on Career Development at Science Europe - Association of European Research Funding Organisations and Research Performing Organisations[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Polymers","post_link":"https://www.bas.bg/?page_id=24272&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Polymers\" width=\"300\" height=\"208\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/polimer-logo_-300x208.gif\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_1fc5e79eefc0b46272cc60aafc4e0ae8%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://polymer.bas.bg","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.673570","%_wpgmp_metabox_longitude%":"23.366853","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Polymers","%acf_bas_fax%":"+359 2 870 03 09","%acf_bas_email%":"<a href=\"mailto:office@polymer.bas.bg\">office@polymer.bas.bg</a>","%acf_bas_latitude%":"42.673570","%acf_bas_longtitude%":"23.366853","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_word_count%":"{\"total\":981,\"to_translate\":{\"en\":981}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17103","%_edit_lock%":"1562772642:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443021","%avada_post_views_count%":"1081","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24272,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Oceanology &#8220;Fridtjof Nansen&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Oceanology &#8220;Fridtjof Nansen&#8221;\" width=\"300\" height=\"222\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/LOGO-IOBAS-300x222.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Oceanology &#8220;Fridtjof Nansen&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 40 Parvi May Str., 9000 Varna, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 52 370 484</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.io-bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.io-bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24441&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"43.17569020000001","lng":"27.909113599999955","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24441&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"40 Parvi May Str., 9000 Varna, Bulgaria","%acf_bas_phone%":"+359 52 370 484","%acf_bas_site%":"<a href=\"http://www.io-bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.io-bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/12/LOGO-IOBAS-300x222.jpg\" alt=\"\" width=\"300\" height=\"222\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Oceanology (IO)</strong> was founded on 22.06.1973 by Order \u2116 132 of the Council of Ministers. Since its establishment, the seat of the Institute is in the city of Varna. The main activities of IO consist in investigations on marine physics, chemistry and geology, archaeology, biology and ecology of the sea, hydrodynamics and lythodynamics of the coastal zone and ocean technologies, complex monitoring of the marine environment in the territorial sea and the Bulgarian economic zone, training of qualified specialists in the area of marine sciences, carrying out consultancy and expert work with application of the research results.</p>\r\n<p style=\"text-align: justify;\">The mission of the institute is to be a national marine scientific and expert center with international authority in the European scientific area.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">The Institute of Oceanology conducts research in the following areas:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>physics, chemistry, biology and ecology of the sea;</li>\r\n \t<li>geology, geomorphology and archaeology of the seabed and the coastal zone;</li>\r\n \t<li>coastal zone hydrodynamics and lythodynamics;</li>\r\n \t<li>marine climatology, hydrology and hydrometeorology;</li>\r\n \t<li>operational oceanography, oceanographic data and information management.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">IO implements complex monitoring of the marine environment in the territorial sea and the Bulgarian economic zone. IO represents BAS as a coordinator of all studies related to the Black Sea and World Ocean at the National Oceanographic Commission (NOC) and successfully coordinates the research activity and international relations within the framework of the Intergovernmental Oceanographic Commission of UNESCO.</p>\r\n<p style=\"text-align: justify;\">In recent years, the most important achievements of the Institute of Oceanology have been the creation of indicator systems for assessing the ecological status of coastal waters under the Water Framework Directive and the state of the marine environment under the Marine Strategy Framework Directive (MSFD); the prepared reports \"Initial assessment of the state of the marine environment\" and \"Formulation of good status of the marine environment. Defining environmental objectives for the marine environment\" under Art. 8, 9 and 10 of the MSFD; improved MSFD monitoring programs; scientifically grounded proposals and documentation under the Biodiversity Act for the extension and announcement of Natura 2000 future protected areas in the Bulgarian waters; estimates of fish stocks and total allowable fish catches; regional guides for the sampling and analysis of marine phytoplankton and macrozoobenthos in the Black Sea; methodologies and technologies for collecting and processing data on litter assessment, eutrophication and noise in marine waters; forecasting systems and early warning on coastal hazards (floods, erosion, earthquakes, landslides, landslips, abrasion) and their impact on the coast to ensure the safety of human life, coastal infrastructure and resources.</p>\r\n\r\n<blockquote>\r\n<p style=\"text-align: justify;\">The Institute is a National Center for Oceanographic Data included in the International Oceanographic Data Exchange and Information System of IOC-UNESCO.</p>\r\n</blockquote>\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">The Institute is accredited by NEAA for training of PhD students under the following programs:</p>\r\n\r\n<ul>\r\n \t<li style=\"text-align: justify;\">\"Oceanology\";</li>\r\n \t<li style=\"text-align: justify;\">\"Ecology and conservation of ecosystems\";</li>\r\n \t<li style=\"text-align: justify;\">\"Hydrobiology\";</li>\r\n \t<li style=\"text-align: justify;\">\"Geology of oceans and seas\".</li>\r\n</ul>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nOnline services\r\n\r\n[/fusion_title][fusion_content_boxes layout=\"icon-on-top\" columns=\"1\" title_size=\"\" heading_size=\"2\" title_color=\"\" body_color=\"\" backgroundcolor=\"#f2efef\" icon=\"\" iconflip=\"\" iconrotate=\"\" iconspin=\"no\" iconcolor=\"#333333\" icon_circle=\"yes\" icon_circle_radius=\"round\" circlecolor=\"rgba(255,255,255,0)\" circlebordersize=\"10\" circlebordercolor=\"\" outercirclebordersize=\"0\" outercirclebordercolor=\"\" icon_size=\"68\" icon_hover_type=\"\" hover_accent_color=\"\" image=\"\" image_id=\"\" image_max_width=\"\" link_type=\"button-bar\" button_span=\"\" link_area=\"link-icon\" link_target=\"_blank\" icon_align=\"left\" animation_type=\"\" animation_delay=\"\" animation_offset=\"\" animation_direction=\"left\" animation_speed=\"0.3\" margin_top=\"40px\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_content_box title=\"Bulgarian National Oceanographic Data Center\" backgroundcolor=\"\" icon=\"fa-anchor fas\" iconflip=\"\" iconrotate=\"\" iconspin=\"no\" iconcolor=\"\" circlecolor=\"\" circlebordersize=\"0\" circlebordercolor=\"\" outercirclebordersize=\"\" outercirclebordercolor=\"\" image=\"\" image_id=\"\" image_max_width=\"35\" link=\"http://www.bgodc.io-bas.bg/\" linktext=\"Click here\" link_target=\"_blank\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" /][/fusion_content_boxes][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]<a href=\"http://www.ioc-unesco.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Intergovernmental Oceanographic Commission of UNESCO (IOC-UNESCO)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://www.blacksea-commission.org/\" target=\"_blank\" rel=\"noopener noreferrer\">The Commission on the Protection of the Black Sea Against Pollution</a>[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://www.egu.eu/\" target=\"_blank\" rel=\"noopener noreferrer\">European Geosciences Union (EGU)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://www.fao.org/gfcm/en/\" target=\"_blank\" rel=\"noopener noreferrer\">General Fisheries Commission for the Mediterranean (GFCM)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://benaweb.gr/\" target=\"_blank\" rel=\"noopener noreferrer\">Balkan Environmental Association (B.EN.A)</a>[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Oceanology &#8220;Fridtjof Nansen&#8221;","post_link":"https://www.bas.bg/?page_id=24441&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Oceanology &#8220;Fridtjof Nansen&#8221;\" width=\"300\" height=\"222\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/LOGO-IOBAS-300x222.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_d83f2ee070b83d728c68cc08c2285b76%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://benaweb.gr/","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"43.17569020000001","%_wpgmp_metabox_longitude%":"27.909113599999955","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Oceanology \"Fridtjof Nansen\"","%acf_bas_fax%":"+359 52 370 483","%acf_bas_email%":"<a href=\"mailto:office@io-bas.bg\">office@io-bas.bg</a>","%acf_bas_latitude%":"43.17569020000001","%acf_bas_longtitude%":"27.909113599999955","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_word_count%":"{\"total\":540,\"to_translate\":{\"en\":540}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17099","%_edit_lock%":"1563018165:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443040","%avada_post_views_count%":"1224","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24441,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Geological Institute &#8220;Strashimir Dimitrov&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Geological Institute &#8220;Strashimir Dimitrov&#8221;\" width=\"290\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/11/LogoGI-Cyr-290x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Geological Institute &#8220;Strashimir Dimitrov&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 24, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 8723 563</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.geology.bas.bg/index_bg.html\" target=\"_blank\" rel=\"noopener\">http://www.geology.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24432&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","content":"yes","location":{"lat":"42.67329409999999","lng":"23.36728489999996","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24432&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 24, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 8723 563","%acf_bas_site%":"<a href=\"http://www.geology.bas.bg/index_bg.html\" target=\"_blank\" rel=\"noopener\">http://www.geology.bas.bg</a>","post_excerpt":"yes","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/11/LogoGI-Cyr-290x300.jpg\" alt=\"\" width=\"290\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>F</strong>[/fusion_dropcap]<strong>or 70 years, the Strashimir Dimitrov Geological Institute (GI)</strong> is a leading unit in the division of Earth Sciences at the Bulgarian Academy of Sciences. It conducts scientific and applied research on all important aspects of geological science in Bulgaria. In recent years, the institute has been regarded as the largest national geological research and scientific-expert organization that combines both classical geology fields and present-day Earth science priorities.</p><p style=\"text-align: justify;\">Maintaining high professionalism and competence of the scientific staff was a prerequisite for the Geological Institute to be a key unit in the implementation of almost all important scientific and applied activities in the field of geology in the country during the second half of the last century:</p><ul style=\"text-align: justify;\"><li>Composition of a geological, tectonic, hydrogeological and gravimetric map of Bulgaria in scale 1:200 000;</li><li>Composition of geological, metallogenic, engineering-geological and geological-hazard maps of Bulgaria in scale 1:500 000;</li><li>Strategy and two national programs for prevention and limitation of landslides on the territory of the Republic of Bulgaria, erosion and abrasion on the Danube and Black Sea coast (1999, 2006 and 2014)</li><li>Analysis, assessment and mapping of the geological risk on the territory of the country (2017)</li><li>Map of the seismic zonation of Bulgaria in scale 1:1 000 000;</li><li>Composition and publishing of a geological map of Bulgaria in 92 sheets with explanatory notes in scale 1:100 000;</li><li>Development and publishing of the multi-volume monograph The Fossils of Bulgaria as well as of a Stratigraphical Codex of Bulgaria;</li><li>Development of the scientific bases for the utilization of the national mineral sources of raw materials; advancing the theory of underground hydrodynamics and regional studies of the underground water characteristics; highly qualified consultancy during the construction of some of the largest dams and other hydro engineering structures (such as Iskar, Golyam Beglik, Belmeken dams, etc.) and many other enterprises important for the national industry: Kozloduy Nuclear Power Plant, Maritsa-Iztok Thermo Power Plants Complex, Devnya chemical plants, etc.;</li><li>Expert activity on the occurrence of dangerous geological phenomena on the territory of the country - landslides etc., in making important decisions for the construction of national infrastructure projects such as LOT 3.2 of Struma Motorway;</li><li>Studies to ensure the safe operation of nuclear facilities (NPPs, RAW repositories), etc.</li></ul><h6 style=\"text-align: justify;\">Scientific activity</h6><p style=\"text-align: justify;\">Nowadays, the main research activities of the Institute are related to the study of the terrestrial environment on the territory of Bulgaria with the main purpose of supporting the sustainable development of the contemporary society and the conflict-free limitation of the consequences of natural hazards.</p><p style=\"text-align: justify;\">Research is geared to two fundamental scientific priorities that are largely interlinked and complementary:</p><ul style=\"text-align: justify;\"><li>Complex regional studies for the acquisition of modern geological knowledge for the territory of Bulgaria, the Balkan Peninsula and the Eastern Mediterranean in the classical geological fields such as palaeontology, stratigraphy and sedimentology; geotectonics and regional geology, geochemistry, mineralogy and petrology;</li><li>geoecological studies, studying and assessing the processes of geological danger for limiting the risk and ensuring the sustainable development of the country. Here are the scientific fields of neotectonics and seismotectonics, hydrogeology, engineering geology, geotechnics and geochemistry of the environment.</li></ul><p style=\"text-align: justify;\">GI scientists represent Bulgaria in over 20 international scientific and expert organizations.</p><h6 style=\"text-align: justify;\">Educational activity</h6><p style=\"text-align: justify;\">Along with the development of scientific themes directly related to the needs of the national economy and society, researchers from the Geological Institute have been carrying out educational activities as early as its establishment. Scientists from the institute have been and are leading university lecturers, supervisors of a significant number of graduates and PhD students. The Institute is accredited by the National Evaluation and Accreditation Agency to train PhD students in 10 specialties.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Geological Institute &#8220;Strashimir Dimitrov&#8221;","post_link":"https://www.bas.bg/?page_id=24432&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Geological Institute &#8220;Strashimir Dimitrov&#8221;\" width=\"290\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/11/LogoGI-Cyr-290x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_595a9f6c6c249bd01daa849d6bbd9add%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.geology.bas.bg/index_bg.html","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.67329409999999","%_wpgmp_metabox_longitude%":"23.36728489999996","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Geological Institute \"Strashimir Dimitrov\"","%acf_bas_fax%":"+359 2 8724 638","%acf_bas_email%":"<a href=\"mailto:geolinst@geology.bas.bg\">geolinst@geology.bas.bg</a>","%acf_bas_latitude%":"42.67329409999999","%acf_bas_longtitude%":"23.36728489999996","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_word_count%":"{\"total\":623,\"to_translate\":{\"en\":623}}","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_duplicate%":"0","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16814","%_edit_lock%":"1563016128:18","%_edit_last%":"18","%pyre_demo_slider%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_last_translation_edit_mode%":"native-editor","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443040","%avada_post_views_count%":"419","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24432,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Space Research and Technology Institute","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Space Research and Technology Institute\" width=\"300\" height=\"227\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/579-300x227.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Space Research and Technology Institute</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 1, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 988 3503 </div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://space.bas.bg\" target=\"_blank\" rel=\"noopener\">http://space.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24455&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.676945","lng":"23.367540","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24455&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 1, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 988 3503 ","%acf_bas_site%":"<a href=\"http://space.bas.bg\" target=\"_blank\" rel=\"noopener\">http://space.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/12/579-300x227.jpg\" alt=\"\" width=\"300\" height=\"227\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Space Research and Technology Institute (SRTI)</strong> conducts fundamental and applied research in the field of space physics, remote sensing of the Earth and planet and aerospace systems and technologies.</p><p style=\"text-align: justify;\">For more than 40 years of its history, SRTI-BAS has achieved significant results in the field of space research: more than 150 scientific instruments and apparatus have been created and put into orbit, and dozens of cosmic experiments under the INTERCOSMOS program and other national and international programs have been conducted. With the launch of the first Bulgarian instrument P-1 in 1972, Bulgaria became the 18th space country in the world.</p><p style=\"text-align: justify;\">The active development of a number of areas in space research led to the creation of a scientific program and equipment for experiments for the two satellites \"Intercosmos Bulgaria - 1300\" and \"Meteor-Nature\".</p><p style=\"text-align: justify;\">SRTI - BAS participated in the preparation and development of the scientific programs of the two space flights with the participation of the Bulgarian cosmonauts Georgi Ivanov (1979) and Alexander Alexandrov (1988 - \"Shipka\" program) with which our country ranked 6th in the world to have cosmonauts.</p><h6 style=\"text-align: justify;\">Scientific activity</h6><p style=\"text-align: justify;\">Main areas of research are:</p><ul style=\"text-align: justify;\"><li>Solar-Terrestrial and Space Physics (solar wind, magnetospheric and ionospheric physics, high and middle atmospheric physics, space weather);</li><li>High-energy astrophysics, galactic cosmic rays;</li><li>Medico-biological studies, space biotechnologies, heliobiology, telemedicine;</li><li>Design, development and transfer of methods, instrumentation and technologies for remote sensing of the Earth, regional and global monitoring of the environment and security;</li><li>Research in the field of obtaining and application of new superhard materials.</li><li>Development of innovative aerospace instrumentation and technologies, as well as their transfer to economy.</li></ul><p style=\"text-align: justify;\">An \"Aerospace Technology Transfer Center\" was set up under a PHARE project at the Institute, which is designed to shorten the transition from innovation to implementation into production, both for its own developments and for innovations from home and abroad. The center is integrated into the network of all such innovation and transfer centers from Europe and the world.</p><h6 style=\"text-align: justify;\">Inventive and patent activities</h6><p><img class=\"alignright\" src=\"/wp-content/uploads/2017/12/patenti-300x216.jpg\" alt=\"\" width=\"300\" height=\"216\" /></p><p style=\"text-align: justify;\">The Space Research and Technology Institute at the Bulgarian Academy of Sciences (SRTI-BAS) has many years of tradition and success in the inventive and patent activities. This is largely motivated and provoked by the object and methods of aerospace research and technology, the need to apply non-traditional methodological and technical solutions, and last but not least the affinity of our scientists and specialists for innovation.</p><p style=\"text-align: justify;\">For over 45 years, scientists from the Institute have created more than 100 developments that have received copyright certificates and patents for inventions, as well as over 15 utility model registration certificates. Their patents are registered besides in Bulgaria also in the US and Ukraine. Patents of SRTI-BAS scientists were announced by the Patent Office of the Republic of Bulgaria \"Invention of the Month\" and were nominated for \"Invention of the Year\".</p><p style=\"text-align: justify;\">With their inventions and useful models, SRTI scientists have participated in dozens of national, international and global innovation forums in Bulgaria, Russia, Belgium, Portugal, Serbia, Macedonia, Poland, Taiwan, Kuwait and others. Gold, silver and bronze medals, diplomas and distinctions, as well as special cups for overall inventive work have been received from almost all participations.<br />Two inventors from the Institute are winners of the title \"Honorable Inventor\" and are listed in the \"Golden Book of Bulgarian Discoverers and Inventors\".</p><p style=\"text-align: justify;\">Educational activity</p><p style=\"text-align: justify;\">IKTI has institutional accreditation for the training of doctoral students under the following programs:</p><ul style=\"text-align: justify;\"><li>Astrophysics and stellar astronomy;</li><li>Physics of the ocean, the atmosphere and the Earth's space;</li><li>Remote sensing of the Earth and Planets;</li><li>Dynamics, ballistics and flight control of aircrafts;</li><li>Automated information processing and management systems</li></ul><p style=\"text-align: justify;\">Currently, 25 PhD students are trained at SRTI.</p><p style=\"text-align: justify;\">Specialized PhD courses on \"Fundamentals of Remote Sensing\" and \"Natural Disasters and Environmental Disasters\" and specialized courses in theoretical and practical training of operators of unmanned aerial vehicles have been developed.</p><p style=\"text-align: justify;\">The \"Space School\" educational initiative is being held to familiarize students interested in space-related science and Earth observation with modern advances in aerospace research and technologies.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"0px\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Inventions and patents</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<ul><li style=\"text-align: justify;\">More than 100 developments that received copyright certificates and patents for inventions</li><li style=\"text-align: justify;\">More than 15 utility model registration certificates</li><li style=\"text-align: justify;\">Patents registered in Bulgaria, USA and Ukraine</li><li style=\"text-align: justify;\">Patents of SRTI-BAS scientists have been announced by the Patent Office of the Republic of Bulgaria \"Inventions of the Month\" and have been nominated for \"Invention of the Year\".</li><li style=\"text-align: justify;\">Participation in dozens of national, international and global innovation forums in Bulgaria, Russia, Belgium, Portugal, Serbia, Macedonia, Poland, Taiwan, Kuwait and others. Nearly all participations received gold, silver and bronze medals, diplomas and distinctions as well as special cups for overall inventive work.</li><li style=\"text-align: justify;\">Two inventors from the Institute are holders of the title \"Honorable Inventor\" and are listed in the \"Golden Book of Bulgarian Discoverers and Inventors\".</li></ul>[/fusion_text][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Space Research and Technology Institute","post_link":"https://www.bas.bg/?page_id=24455&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Space Research and Technology Institute\" width=\"300\" height=\"227\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/579-300x227.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_fbf86a5ac1e22ea2e2e7013873f347cc%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://space.bas.bg","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.676945","%_wpgmp_metabox_longitude%":"23.367540","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Space Research and Technology Institute","%acf_bas_fax%":"+359 2 988 3503","%acf_bas_email%":"<a href=\"mailto:office@space.bas.bg\">office@space.bas.bg</a>","%acf_bas_latitude%":"42.676945","%acf_bas_longtitude%":"23.367540","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_word_count%":"{\"total\":821,\"to_translate\":{\"en\":821}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17074","%_edit_lock%":"1563023729:18","%_edit_last%":"18","%pyre_demo_slider%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_last_translation_edit_mode%":"native-editor","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443043","%avada_post_views_count%":"753","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24455,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Experimental Morphology, Pathology and Anthropology with Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Experimental Morphology, Pathology and Anthropology with Museum\" width=\"121\" height=\"122\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/logo.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Experimental Morphology, Pathology and Anthropology with Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 25, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 23 11, +359 2 870 49 21 (museum)</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.iempam.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.iempam.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24383&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","address":"\u0418\u041d\u0421\u0422\u0418\u0422\u0423\u0422 \u041f\u041e \u0415\u041a\u0421\u041f\u0415\u0420\u0418\u041c\u0415\u041d\u0422\u0410\u041b\u041d\u0410 \u041c\u041e\u0420\u0424\u041e\u041b\u041e\u0413\u0418\u042f \u0418 \u0410\u041d\u0422\u0420\u041e\u041f\u041e\u041b\u041e\u0413\u0418\u042f, \u0421\u043e\u0444\u0438\u044f, \u0411\u044a\u043b\u0433\u0430\u0440\u0438\u044f","location":{"lat":"42.6738941","lng":"23.36847869999997","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24383&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 25, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 23 11, +359 2 870 49 21 (museum)","%acf_bas_site%":"<a href=\"http://www.iempam.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.iempam.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/12/logo_IEMPAM-300x300.png\" alt=\"\" width=\"300\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Experimental Morphology, Pathology and Anthropology with Museum (IEMPAM)</strong> conducts complex fundamental and applied research in the field of humane and veterinary medicine, including morphology, cell biology, pathology and anthropology which have a significant role in solving important health and demographic problems. The subject area of the institute is unique for Bulgaria.</p>\r\n<p style=\"text-align: justify;\">IEMPAM was established on July 1, 2010 as a successor of the Institute of Experimental Morphology and Anthropology with a Museum and the Institute of Experimental Pathology and Parasitology. IEMPAM inherited a rich history which had begun as early as the middle of the last century (1947-1948) when the Institute of Experimental Medicine (IEM) and the Institute of Experimental Veterinary Medicine (IEVM) were founded.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">IEMPAM's activities are in line with the national and European priorities of Health, Food Safety, Environment, National Identity and Cultural-Historical Heritage.</p>\r\n<p style=\"text-align: justify;\">In the field of experimental morphology and pathology, the pathological and clinical aspects of current diseases of infectious, non-infectious and parasitic nature are studied. The regulatory mechanisms of cell differentiation are investigated, and the pathogenesis of various socially significant diseases is being clarified. Diagnostic methods are developed and biomarkers for degenerative, cancer and autoimmune diseases, infections and infertility are identified. Experimental model systems study the impact of the environment and lifestyle on human health. A comprehensive approach (in vitro, in vivo and in ovo) is being carried out to study the biological activity and safety of chemical and biological products. Expert activity is carried out for the needs of the biotechnology industry and for the diagnostics of animal diseases accompanied by major economic losses.</p>\r\n<p style=\"text-align: justify;\">Anthropological and anthropogenic characterization of the population of Bulgaria is carried out in the field of anthropology; the development of the anthropological types on the Bulgarian lands is being clarified. The processes of acceleration and deceleration are studied; normative indicators for physical development are created; anthropometric markers for the diagnostics of different diseases are being developed in accordance with the European and national priorities \"Health\" and \"Environment\".</p>\r\n<p style=\"text-align: justify;\">Among the achievements of the scientists of IEMPAM, the following should be noted:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Creation of a series of vaccines against poultry and cattle diseases accompanied by major economic losses.</li>\r\n \t<li>Creation of a comprehensive approach to assess the biocompatibility of new bone implant materials for application in orthopedics and dental medicine.</li>\r\n \t<li>Development of anthropometric norms that provide monitoring of the physical development of adolescents and the biological status of the population benefiting health professionals and nutritionists.</li>\r\n \t<li>Clarification of the impact of anthropogenic pollutants (metals, hormone disruptors, etc.) on human hematopoiesis and reproductive health.</li>\r\n \t<li>Development of new substrates for the localization of enzymes with application in clinical practice.</li>\r\n \t<li>Clarification of the etiology and pathogenesis of neurodegenerative (Alzheimer's disease, non-transmissible and transmissible encephalopathies, multiple sclerosis, etc.) and systemic autoimmune diseases.</li>\r\n \t<li>Tracing the patomorphological aspects of current viral and bacterial diseases in domestic and wild animals.</li>\r\n \t<li>Carrying out comprehensive studies on epidemiology, clinical manifestations and diagnostics of parasitoses in animals and humans.</li>\r\n \t<li>Investigating the host-parasite system as a component of the biomonitoring on environmental pollution.</li>\r\n \t<li>Developing the new direction of virtual anthropology - a modern interdisciplinary approach to biomedical research.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The National Anthropological Museum (NAM) is a unique scientific, educational and cultural institution that carries out and presents original anthropological reconstructions and exhibits and promotes modern anthropological knowledge in order to preserve national memory and identity in accordance with the priorities \"National Identity\" \"Cultural-Historical Heritage\". NAM is the leading national center in the analysis of human bones from archaeological excavations. The travelling version of the museum and the thematic expositions created popularize nationally the anthropological knowledge.</p>\r\n<p style=\"text-align: justify;\">The Institute publishes, through the Academic Publishing House \"Prof. Marin Drinov\", the series \"Acta Morphologica et Anthropologica\" - the only morphological journal in Bulgaria which is an organ of IEMPAM-BAS and the Bulgarian Anatomical Society. It is referenced in the electronic database BIOSIS Previews and is currently listed under number 76 in the Thomson Reuters Master Journal List. The journal's publishing policy has recently been refined, with a view to a preliminary assessment by SCOPUS and transition to a monitored regime.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">IEMPAM is accredited by NEAA for training of PhD students under the following programs:\r\n4.3 Biological Sciences - Morphology\r\n4.3 Biological Sciences - Anthropology\r\n4.3 Biological Sciences - Biochemistry\r\n4.3 Biological Sciences - Parasitology and Helminthology\r\n4.3 Biological Sciences - Immunology\r\n4.3 Biological Sciences - Virology\r\n6.4 Veterinary medicine - Pathology of animals\r\n6.4 Veterinary medicine - Parasitology and invasive diseases in animals and humans</p>\r\n<p style=\"text-align: justify;\">Experts from IEMPAM hold lecture courses and exercises at:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Center at the Bulgarian Academy of Sciences</li>\r\n \t<li>Faculty of Biology, Sofia University \"St. Kl. Ohridski\"</li>\r\n \t<li>University of Forestry \u2013 Sofia</li>\r\n \t<li>South-West University \"Neofit Rilski\" \u2013 Blagoevgrad</li>\r\n \t<li>\"St. Cyril and St. Methodius\" University of Veliko Tarnovo</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The Institute participates in the MES \"Student Practices\" projects and trains graduates from different Higher Education Institutions. In IEMPAM, Bachelor and Master Students from SU \"St. Kl. Ohridski\" prepare their theses and doctoral students, post-doctoral students and post-graduate students from other countries are trained.</p>\r\n<p style=\"text-align: justify;\">IEMPAM organizes scientific forums for the presentation of papers and posters by students, PhD students and young scientists. The youth workshop on biomedicine with international participation \"Experimental oncology and tissue engineering\" and the seminar and summer school for students and young scientists \"The Bright World of Biomedicine\" are traditional.</p>\r\n<p style=\"text-align: justify;\">Educational activities are also carried out at the National Anthropological Museum. There are lectures, including in Russian and in English, public lectures, and group visits of students and soldiers. The Museum organizes and conducts museum lessons, and lectures before pupils\u2019 groups from secondary schools within the Educational Program for Complementary Education in History are organized.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"]\r\n\r\n[acf field=\"acf_bas_site\"]\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Experimental Morphology, Pathology and Anthropology with Museum","post_link":"https://www.bas.bg/?page_id=24383&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Experimental Morphology, Pathology and Anthropology with Museum\" width=\"121\" height=\"122\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/logo.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_8070584debb49a3f017c6c7e12a4e8c9%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.iempam.bas.bg/","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"\u0418\u041d\u0421\u0422\u0418\u0422\u0423\u0422 \u041f\u041e \u0415\u041a\u0421\u041f\u0415\u0420\u0418\u041c\u0415\u041d\u0422\u0410\u041b\u041d\u0410 \u041c\u041e\u0420\u0424\u041e\u041b\u041e\u0413\u0418\u042f \u0418 \u0410\u041d\u0422\u0420\u041e\u041f\u041e\u041b\u041e\u0413\u0418\u042f, \u0421\u043e\u0444\u0438\u044f, \u0411\u044a\u043b\u0433\u0430\u0440\u0438\u044f","%_wpgmp_metabox_latitude%":"42.6738941","%_wpgmp_metabox_longitude%":"23.36847869999997","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Experimental Morphology, Pathology and Anthropology with Museum","%acf_bas_fax%":"+359 2 871 01 07, +359 2 871 83 75 (museum)","%acf_bas_email%":"<a href=\"mailto:iempam@bas.bg\">iempam@bas.bg</a>","%acf_bas_latitude%":"42.6738941","%acf_bas_longtitude%":"23.36847869999997","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_word_count%":"{\"total\":966,\"to_translate\":{\"en\":966}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17037","%_edit_lock%":"1562860726:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443032","%avada_post_views_count%":"700","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24383,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Georgi Nadjakov Institute of Solid State Physics","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Georgi Nadjakov Institute of Solid State Physics\" width=\"219\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/logo_issp_new1-219x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Georgi Nadjakov Institute of Solid State Physics</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 72 Tsarigradsko Shosse Blvd., 1784 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 875 80 61</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.issp.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.issp.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24194&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.652396","lng":"23.388831","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24194&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"72 Tsarigradsko Shosse Blvd., 1784 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 875 80 61","%acf_bas_site%":"<a href=\"http://www.issp.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.issp.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/12/logo_issp_new1-219x300.jpg\" alt=\"\" width=\"219\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>G</strong>[/fusion_dropcap]<strong>eorgi Nadjakov Institute of Solid State Physics (ISSP) </strong>was founded in 1972 with the aim to develop fundamental and applied research in the fields of microelectronics, acoustoelectronics, physics of superconductors and low temperature physics, optics and spectroscopy. Throughout the years ISSP grew up covering new modern areas like liquid crystal physics, soft and living matter physics, nanophysics.</p><p style=\"text-align: justify;\">The main scientific and applied achievements of the Institute are in the field of condensed matter theory, critical phenomena and phase transitions, superconductivity and superconducting materials, low temperature physics, nanophysics, liquid crystal physics, soft and living matter physics, structure and properties of crystals and amorphous materials, atom and plasma physics, high precision thermometers, integrated optics, optical fibres, acoustoelectric and microelectronic sensors, metal vapour lasers.</p><p style=\"text-align: justify;\">Nowadays, the mission of the Institute consists in the development, dissemination and storage of knowledge in condensed matter physics, optics, spectroscopy and laser physics; application of this knowledge for the creation of new materials with specific properties for various applications, development of new analytical methods for micro- and nano-technologies as well as new approaches in the interdisciplinary fields of physics with biology, archaeology, medicine etc; transfer of innovations to the industry of Bulgaria and the EU.</p><h6 style=\"text-align: justify;\">Scientific activity</h6><p style=\"text-align: justify;\">The main areas of work at ISSP are:</p><ul style=\"text-align: justify;\"><li>Functional materials and nanostructures</li><li>Laser physics, atomic physics and applications</li><li>Soft matter systems for different applications</li></ul><p style=\"text-align: justify;\">Since its establishment, the Institute actively participates in the training of young scientists and provides helpful research results for energetics, the preservation of cultural heritage, national defense, medicine, integral and functional electronics. The main scientific achievements of ISSP are in:</p><ul style=\"text-align: justify;\"><li>Research and modeling of physical and chemical processes in condensed environments, phases and phase transitions, properties of non-linear dynamic systems.</li><li>Physics and technology of thin inorganic semiconductor and dielectric layers, carbon nanostructures, nanostructured biomaterials and liquid crystals; applications in nanoelectronics, opto- and acoustic-electronics, sensing devices.</li><li>Crystal growth; multifunctional magnetic systems and superconductors.</li><li>Photonics, optics and spectroscopy in nonlinear and anisotropic environments.</li><li>Laser and atomic physics, applications of lasers in archaeometry, medicine, nanotechnologies, ecology.</li></ul><p style=\"text-align: justify;\">ISSP has at its disposal a rich variety of scientific equipment, precise methods and technologies:</p><ul style=\"text-align: justify;\"><li>Thin film and bulk material technology: clean room with a system for atomic layer deposition (ALD) -TFS200 Beneq and plasma enhanced system for chemical vapour deposition (PECVD)-Oxford Nanolab PlasmaLab System 100; high-vacuum technological system for deposition of thin optic films Symphony 9; furnace (Carbolite, UK) for the synthesis of high-temperature superconducting materials; equipment and technology for applying thin layers for microelectronic, optoelectronic and acoustic electronic sensors; equipment and know-how for single crystal growth from oxide materials.</li><li>Unique measurement equipment (Physical Properties Measurement System produced by Quantum Design, USA) for studies of electrical, magnetic and thermal properties of materials, surfaces and structures; Keithley 4200-SCS semiconductor parameter analyzer integrated with a pulse generator; electrical measurement systems for micro- and nanoelectronic structures; system for the study of the sorption properties of quartz microscales with different coatings in gas phase; electrochemical impedance spectroscopy system, Bio-Logic SP-200.</li><li>Structural and spectroscopic methods: scanning probe microscope (VEECO, Multimode V, USA) to conduct accurate nanoscale studies of the morphological, electrical, magnetic and other surface properties; spectral-ellipsometric measurements (M2000D automatic ellipsometer suitable for samples with thickness less than 0.1nm); spectrometry from vacuum ultraviolet to infrared spectral regions (BRUKER - Vertex 70 and Perkin Elmer - Lambda 1050 spectrophotometers).</li><li>Laser systems: various laser systems - metal vapor gas lasers, solid nanosecond lasers emitting in UV, visible and near IR spectral area, and Spectra-Physics femtosecond laser system with the ability to adjust the wavelength from 260 to 2600 nm for the needs of plasma physics, laser analysis and materials processing, with applications in nanotechnology, medicine, archaeology, ecology, etc.; high-tech experimental laser equipment for atomic cooling (~ 0.0001 K).</li><li>Apparatus for the study of biophysical objects: equipment for video microscopy and micromanipulation of lipid membranes and cells for conducting experimental studies of physicochemical properties, determination of flexural and stretch elastic moduli; permeability; morphology, etc.; an automated microfluidic system and a compact cytometer, CellASIC &#x2122; ONIX, Merck Millipore, Scepter 2.0 (EMD Millipore) for kinetics research of various biological objects, automated tracking and analysis of processes running in living cells over a prolonged time interval; Laboratory MaxiMem membrane filtration system from Prozesstechnik GmbH for extraction and concentration, purification and desalination, membrane filtration and recycling.</li></ul><h6 style=\"text-align: justify;\">Educational activity</h6><p style=\"text-align: justify;\">The Institute has accreditation for the right to teach in the educational and scientific degree \"doctor\" in professional fields 4.1. \"Physical Sciences\" and 4.3. \"Biological Sciences\" in the following specialties:</p><ul style=\"text-align: justify;\"><li>Condensed matter physics;</li><li>Laser Physics, Physics of Atoms, Molecules and Plasma, and Physics of Wave Processes;</li><li>Biophysics (Physics of Living Matter).</li></ul><p style=\"text-align: justify;\">ISSP scientists lecture and train students in general physics, thermodynamics and statistical physics, analytical chemistry at Sofia University, Sofia Technical University, UACEG, UCTM, etc. These lectures are in new, modern areas such as soft matter physics, bioelectronics and disordered systems. There are also special courses in solid state physics, superconductivity, magnetism, eco-physics, etc. Scientists from the Institute have lectures on theoretical physics, solid physics, mathematical methods, biophysics in a number of universities abroad (Slovenia, Spain, Germany, Belgium).</p><p style=\"text-align: justify;\">Acad. Georgi Nadjakov Solid State Physics Institute has accumulated 40 years of experience in the education of students and training at postgraduate, doctoral and post-doctoral level. For the period 2010-2016, over 20 PhD students successfully defended their theses, and a large number of graduates and postgraduates were prepared. ISSP scientists were supervisors or consultants of PhD students who successfully defended their theses abroad while the dissertations of some of them were being written for the most part at ISSP.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Georgi Nadjakov Institute of Solid State Physics","post_link":"https://www.bas.bg/?page_id=24194&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Georgi Nadjakov Institute of Solid State Physics\" width=\"219\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/logo_issp_new1-219x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_94eb512a0ad50840631e3415ac9cae35%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.issp.bas.bg","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.652396","%_wpgmp_metabox_longitude%":"23.388831","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Georgi Nadjakov Institute of Solid State Physics","%acf_bas_fax%":"+359 2 416 93 57","%acf_bas_email%":"<a href=\"mailto:office@issp.bas.bg\">office@issp.bas.bg</a>","%acf_bas_latitude%":"42.652396","%acf_bas_longtitude%":"23.388831","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_word_count%":"{\"total\":950,\"to_translate\":{\"en\":950}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17093","%_edit_lock%":"1562675624:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443013","%avada_post_views_count%":"567","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24194,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Organic Chemistry with Centre of Phytochemistry","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Organic Chemistry with Centre of Phytochemistry\" width=\"300\" height=\"225\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/sgrada-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Organic Chemistry with Centre of Phytochemistry</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 9, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 960 6112</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.orgchm.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.orgchm.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24236&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","address":"\u0418\u043d\u0441\u0442\u0438\u0442\u0443\u0442 \u043f\u043e \u043e\u0440\u0433\u0430\u043d\u0438\u0447\u043d\u0430 \u0445\u0438\u043c\u0438\u044f \u0441 \u0446\u0435\u043d\u0442\u044a\u0440 \u043f\u043e \u0444\u0438\u0442\u043e\u0445\u0438\u043c\u0438\u044f, \u0421\u043e\u0444\u0438\u044f, \u0411\u044a\u043b\u0433\u0430\u0440\u0438\u044f","location":{"lat":"42.6752584","lng":"23.367708799999946","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24236&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 9, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 960 6112","%acf_bas_site%":"<a href=\"http://www.orgchm.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.orgchm.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/12/logo_IOCCP-BAS-300x137.jpg\" alt=\"\" width=\"300\" height=\"137\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Organic Chemistry with Centre of Phytochemistry (IOCCP)</strong> was founded in 1960 and is, nowadays, the leading scientific institution in the field of organic and bio-organic chemistry in Bulgaria. In 1977, a Center of Phytochemistry was set up at it in a joint project of the Bulgarian Government, UNDP and UNESCO for scientific and applied research and training of specialists in the field of organic chemistry and chemistry of natural products. Since then, the Institute has been named the Institute of Organic Chemistry with the Center of Phytochemistry (IOCCP).</p>\r\n<p style=\"text-align: justify;\">IOCCP scientists are working on implementing a number of scientific projects funded by the National Science Fund, EU and NATO programs, the Swiss National Science Foundation and other international organizations. The successful development of the Institute is also related to the solving of scientific and applied tasks in the framework of contracts with companies from the country and abroad - Actavis, Sopharma, Johnson and Johnson (Jansen Pharmaceuticals - Belgium), Polyenergy - France, Ipsen - France and many others.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Major research areas in the activities of IOCCP</h6>\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Organic chemistry - selective synthesis of bioactive compounds and materials for modern technologies; study of mechanisms and stereochemistry of organic reactions, spectral and theoretical studies as well as a connection between structure and reactivity. The main synthetic efforts are aimed at developing new approaches for the production of multifunctional organic compounds and materials with applications in life sciences and nanotechnologies.</li>\r\n \t<li>Chemistry of Natural Organic Substances - the better part of the research is devoted to Bulgarian medicinal and aromatic plants, bee products and non-poisonous mushrooms in which our country is particularly rich, and in searching for opportunities to create innovative products with them of high added value. Lipid chemistry - developing methods and technologies for creating functional foods and nutritional supplements aimed at improving the quality of life.</li>\r\n \t<li>Bioorganic chemistry - isolation and structural characterization of proteins, glycoproteins, peptides, glycopeptides and glycolipids. Scientific and applied research on new biomaterials for use in medicine and pharmacy, studying the mechanisms of biologically important reactions.</li>\r\n \t<li>Study of the composition and products from the processing of solid fuels and biomass. Development of high-performance porous adsorbents and catalysts with application in ecology, pharmacy and advanced technologies.</li>\r\n</ul>\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">IOCCP-BAS has an institutional accreditation for the training of doctoral students on the following programs: organic chemistry, bio-organic chemistry and chemistry of natural and physiologically active substances, theoretical chemistry, petrochemistry and petrochemical synthesis, synthetic and natural fuels technology.</p>\r\n<p style=\"text-align: justify;\">The Institute has more than 80 participations in the implementation of the project \"Student Practices\", financed under OP \"Human Resources Development\", co-financed by the European Social Fund.</p>\r\n<p style=\"text-align: justify;\">The scientists from IOCCP-BAS hold lectures under Bachelor's and Master's programs at the Faculty of Chemistry and Pharmacy \"St. Kliment Ohridski\", the University of Mining and Geology \"St. Ivan Rilski\", the University of Rousse \"Angel Kanchev\"- branch Razgrad, University of Chemical Technology and Metallurgy \u2013 Sofia as well as lecture courses at BAS Training Center.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Organic Chemistry with Centre of Phytochemistry","post_link":"https://www.bas.bg/?page_id=24236&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Organic Chemistry with Centre of Phytochemistry\" width=\"300\" height=\"225\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/sgrada-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_a57a0a193caf6341de55c7b7db0c413d%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.orgchm.bas.bg/~nmr/Service.htm","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"\u0418\u043d\u0441\u0442\u0438\u0442\u0443\u0442 \u043f\u043e \u043e\u0440\u0433\u0430\u043d\u0438\u0447\u043d\u0430 \u0445\u0438\u043c\u0438\u044f \u0441 \u0446\u0435\u043d\u0442\u044a\u0440 \u043f\u043e \u0444\u0438\u0442\u043e\u0445\u0438\u043c\u0438\u044f, \u0421\u043e\u0444\u0438\u044f, \u0411\u044a\u043b\u0433\u0430\u0440\u0438\u044f","%_wpgmp_metabox_latitude%":"42.6752584","%_wpgmp_metabox_longitude%":"23.367708799999946","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Organic Chemistry with Centre of Phytochemistry","%acf_bas_fax%":"+359 2 870 0225","%acf_bas_email%":"<a href=\"mailto:office@orgchm.bas.bg\">office@orgchm.bas.bg</a>","%acf_bas_latitude%":"42.6752584","%acf_bas_longtitude%":"23.367708799999946","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_word_count%":"{\"total\":544,\"to_translate\":{\"en\":544}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17030","%_edit_lock%":"1562685011:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"default_sidebar","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":"default_sidebar"},"%_alp_processed%":"1624443017","%avada_post_views_count%":"1967","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24236,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Electronics &#8220;Academician Emil Djakov&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Electronics &#8220;Academician Emil Djakov&#8221;\" width=\"300\" height=\"227\" src=\"https://www.bas.bg/wp-content/uploads/2017/11/IE-building-300x227.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Electronics &#8220;Academician Emil Djakov&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 72 Tsarigradsko Shosse Blvd., 1784 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 875 0077</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.ie-bas.org/\" target=\"_blank\" rel=\"noopener\">http://www.ie-bas.org/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24199&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.653803","lng":"23.387368","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24199&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"72 Tsarigradsko Shosse Blvd., 1784 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 875 0077","%acf_bas_site%":"<a href=\"http://www.ie-bas.org/\" target=\"_blank\" rel=\"noopener\">http://www.ie-bas.org/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"aligncenter\" src=\"/wp-content/uploads/2017/11/IE-logo-1024x104.jpg\" alt=\"\" width=\"1024\" height=\"104\" />\r\n[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Electronics \"Academician Emil Djakov\"</strong> was established in 1963 as a non-profit state organization conducting research, education and dissemination of scientific knowledge in the fields of Physical Electronics, Photonics and Quantum Electronics and Radiophysics. Through the several decades of its history, the Institute's research activities have comprised dynamically developing fields of applied physics and technologies such as development, treatment and analysis of hich-tech materials, physics of nano-sized objects and nanotechnologies, nanoelectronics, opto-electronics, quantum optics, environmental physics and monitoring, biomedical photonics.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Research and expert activities</h6>\r\n<p style=\"text-align: justify;\">The research efforts in physical electronics are concentrated on studying and solving the problems of generating and controlling electron and ion beams and their interaction with materials in particular. This includes the development of new methods, theoretical modeling, research and industrial equipment for micro- and nano-structuring, thin films deposition and study, modification of surfaces, vacuum melting and welding of metals by intense electron beams. The physical basis of technologies is studied for creating nanostructures, nanomaterials and nanoelements by using electron and ion beams. Computer simulation and experimental investigation of electron and ion lithography of sub-micron and nanoelectronic structures are carried out. The possibilities of creating nanomaterials and nanoelectronic elements using superconducting and polymeric layers as well as experimental devices on their basis are studied. Another field of study is the study of the fundamental properties of gases and plasma of noble gases and metal vapors, the restoration of the electron-molecule interaction sections, the modelling of binary interactions in molecular gases for applications in industry, ecology and spectroscopy; investigation of arc plasma and creation of plasma meters for technological applications; plasma assisted formation of thin layers and coatings and realization of plasma-chemical processes.</p>\r\n<p style=\"text-align: justify;\">\r\nThe research in photonics and quantum electronics comprises theoretical and experimental studies on the interaction of short and ultrashort lasers pulses with matter; development of novel technologies based on near-field optics, plasmonics and nanostructuring; laser deposition and treatment of active and passive optic and magnetic thin films; light-induced absorption and transmission in alkaline vapors for application in metrology; development of complex laser systems for analysis and modification of semiconducting and superconducting materials; theoretical and experimental investigation of non-linear optical phenomena; biomedical photonics.</p>\r\n<p style=\"text-align: justify;\">\r\nThe research efforts in radiophysics are directed to clarifying the processes of interaction of optical and microwave electromagnetic radiation with the atmosphere and the Earth's surface; laser remote sensing and monitoring of the atmosphere; microwave remote radiometric measurement of soil moisture content; methods for detecting, strengthening and processing of signals in order to receive and interpret information; constructing microwave units and systems for radar and communication applications; studying non-linear processes in optical communication media.</p>\r\n<p style=\"text-align: justify;\">\r\nThe Academician Emil Djakov Institute of Electronics was where the first Bulgarian laser, lidar, ultrahigh vacuum pump, micro-channel electron-optical converter, parametric microwave amplifier, Josephson junctions and SQUID, portable microwave moisture meter, magnetometer, installations for electron lithography, electron beam melting, refining, and welding were built, followed by the development of several advanced e-beam, laser and plasma technologies, novel types of gas sensors as well as methods for nanostructured materials formation.</p>\r\n<p style=\"text-align: justify;\">\r\nScientists from the Institute are actively working as experts in a number of governmental and international organizations, such as the National Science Fund, scientific councils in other institutes within the Bulgarian Academy of Sciences, academic councils of universities, editorial boards of Bulgarian and international scientific journals, expert councils of the European Commission, program committees of national and international scientific events. Winners of the \"Pythagoras\" National Award of the Ministry of Education and Science for the best scientists in Bulgaria until 2017 are three of IE employees. The only scientists from Eastern Europe nominated for the Decartes Award in 2004 are also working for IE. Every year, scientists from the Institute of Electronics hold about 35 training courses in ten universities in Bulgaria. Associates of the Institute visit universities in countries of the European Union, Japan and others.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">The Institute of Electronics has accreditation to teach PhD students for the period 2014-2019 in the following fields of higher education 4 \"Natural sciences, Mathematics and Informatics\", professional field 4.1. \"Physical Sciences\", by scientific specialties:</p>\r\n\r\n<ol>\r\n \t<li style=\"text-align: justify;\">Radio physics and physical electronics</li>\r\n \t<li style=\"text-align: justify;\">Physics of wave processes</li>\r\n \t<li style=\"text-align: justify;\">Physics of atoms and molecules</li>\r\n \t<li style=\"text-align: justify;\">Mathematical modelling and application of mathematics in physics</li>\r\n \t<li style=\"text-align: justify;\">Plasma Physics and Gas Discharge</li>\r\n</ol>\r\n<p style=\"text-align: justify;\">\r\nIE-BAS actively participates in the educational program for qualitative and competitive training with different forms of education, educational initiatives and contracts for cooperation with other educational organizations and higher education institutions in Bulgaria. Within the framework of the training initiatives of IE-BAS, students and graduates have been taught from the University of Sofia, Plovdiv University, Technical University-Sofia, TU-branch Plovdiv, TU Sofia-MTF, MGU-Sofia, UCTM-Sofia while members of the team of IE-BAS held lectures and exercises and were supervisors of Master's and Bachelor's graduate theses.</p>\r\n<p style=\"text-align: justify;\">\r\nIntensive work is being done within existing international collaborations and / or specializations of scientists from IE-BAS abroad, with trainings of students and PhD students at Saratov State University, Russia, University of Keio, Japan, Clemson University, USA and others.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p></p>[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Electronics &#8220;Academician Emil Djakov&#8221;","post_link":"https://www.bas.bg/?page_id=24199&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Electronics &#8220;Academician Emil Djakov&#8221;\" width=\"300\" height=\"227\" src=\"https://www.bas.bg/wp-content/uploads/2017/11/IE-building-300x227.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_e9208f6c9c2415d94b51073ae1055a46%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.ie-bas.org/","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.653803","%_wpgmp_metabox_longitude%":"23.387368","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Electronics \"Academician Emil Djakov\"","%acf_bas_fax%":"+359 2 975 3201","%acf_bas_email%":"<a href=\"mailto:die@ie.bas.bg\">die@ie.bas.bg</a>","%acf_bas_latitude%":"42.653803","%acf_bas_longtitude%":"23.387368","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_word_count%":"{\"total\":878,\"to_translate\":{\"en\":878}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16955","%_edit_lock%":"1562676291:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443014","%avada_post_views_count%":"501","%avada_today_post_views_count%":"4","%avada_post_views_count_today_date%":"19-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24199,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute for the State and the Law","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for the State and the Law\" width=\"125\" height=\"125\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/LOGO_IDP.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute for the State and the Law</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 4 Serdica Str., 1000 Sofia</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 987 49 02</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://ipn-bg.org\" target=\"_blank\" rel=\"noopener\">http://ipn-bg.org</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24525&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.69811550000001","lng":"23.324907499999995","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24525&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"4 Serdica Str., 1000 Sofia","%acf_bas_phone%":"+359 2 987 49 02","%acf_bas_site%":"<a href=\"http://ipn-bg.org\" target=\"_blank\" rel=\"noopener\">http://ipn-bg.org</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/LOGO_IDP.png\" alt=\"\" width=\"125\" height=\"125\" /> [fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute for the State and the Law (ISL)</strong> was established in 1947 and is the only scientific unit in the system of the Bulgarian Academy of Sciences which carries out fundamental and applied research in the field of law. It carries out active scientific-expert and consulting activities in support of the legislative, executive and judiciary authorities. ISL is part of the scientific division \"Man and Society\" of BAS.</p><p style=\"text-align: justify;\">The mission of ISL is manifested in its three main current priorities:</p><ul><li>Supporting the law-making function of the state, the law enforcement, the activity of the judicial and the administrative bodies;</li><li>Research in the field of harmonization of Bulgarian law with EU law, in international public, private law and international relations;</li><li>Research on fundamental and practical problems of the legal system.</li></ul><p style=\"text-align: justify;\">ISL was an active participant in the Bulgarian presidency of the Council of EU in cooperation with the government and the non-governmental sector. In June 2017, a conference \"10 Years of Membership of the Republic of Bulgaria in the EU: Issues of Harmonization and Implementation of EU Law\" was organized. The reports were published in a collection that was presented during the Bulgarian presidency.</p><p style=\"text-align: justify;\">The history of ISL is marked by the great scholars who worked in it: Academician Stefan Balamezov, Acad. Petko Staynov, Acad. Lyuben Vasilev, Acad. Stefan Pavlov, Acad. Kostadin Lyutov, Prof. Jivko Stalev, Prof. Petko Radoynov, corr.-member Prof. Neno Nenovski and others. A total of 35 prominent jurists - scientists and public figures - contributed to the establishment, development and validation of BAS as a scientific organization. Of these, five academicians and two corresponding members.</p><h6 style=\"text-align: justify;\">Research activity</h6><p style=\"text-align: justify;\">The scientific research activity of ISL is devoted to current and important issues and practices of Bulgarian legal science as well as to the law of the European Union and international law. The scientific directions of the collective projects are as follows:</p><ul><li>\"Constitutional, Administrative and Sociological Problems of Law in Rulemaking\", led by Assoc. Prof. Dr. Nadezhda Yonkova;</li><li>\"Current Problems of Private Law\", led by Assoc. Prof. Dr. Nikolay Kolev;</li><li>\"Criminal Justice Measures in Countering Crime in Bulgaria\", led by Assoc. Prof. Gergana Marinova;</li><li>\"Migration - Challenge to International Public Law, Private International Law and EU Law\", led by Prof. Dr. Irena Ilieva.</li><li>\"Legal Regulation of the Activities of Small and Medium-sized Enterprises in the Law of the EU and the Republic of Bulgaria. Harmonization or Disharmony?\" led by Prof. Dr. Irena Ilieva.</li></ul><h6 style=\"text-align: justify;\">Education</h6><p style=\"text-align: justify;\">ISL prepares highly qualified researchers and PhD students in the field of legal science and for law education in various higher education institutions.</p><p style=\"text-align: justify;\">To date, 36 PhD students are trained at ISL, 3 of which are regular, 27 part-time and 1 - in an independent form of training under 8 accredited doctoral programs: Constitutional Law, Administrative Law and Administrative Process, Legal Sociology. Legal Informatics, Civil and Family Law, Business / Commercial Law, International Law and International Relations, International Private Law and Criminal Procedure.</p><p style=\"text-align: justify;\">Other educational initiatives involving ISL are Master programs with universities (Varna Free University \"Chernorizets Hrabar\", University of Economics - Varna).</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute for the State and the Law","post_link":"https://www.bas.bg/?page_id=24525&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for the State and the Law\" width=\"125\" height=\"125\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/LOGO_IDP.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.69811550000001","%_wpgmp_metabox_longitude%":"23.324907499999995","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute for the State and the Law ","%acf_bas_fax%":"+359 2 987 49 02","%acf_bas_email%":"<a href=\"mailto:ipn_ban@bas.bg\">ipn_ban@bas.bg</a>","%acf_bas_latitude%":"42.69811550000001","%acf_bas_longtitude%":"23.324907499999995","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%pyre_wooslider%":"","%_oembed_bcd6cb8dbdba269eb0dc980477e3d8bc%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://ipn-bg.org","%_gallery_link_target%":"_blank","%_wpml_word_count%":"{\"total\":549,\"to_translate\":{\"en\":549}}","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_duplicate%":"0","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"24522","%_edit_lock%":"1563112606:18","%_edit_last%":"18","%pyre_demo_slider%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_last_translation_edit_mode%":"native-editor","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443051","%avada_post_views_count%":"349","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24525,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Economic Research Institute","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Economic Research Institute\" width=\"254\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/11/logo_2010_B-254x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Economic Research Institute</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 3 Aksakov Str., 1000 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 810 40 15, +359 2 810 40 18</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.iki.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.iki.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24518&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.69495020000001","lng":"23.327629800000068","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24518&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"3 Aksakov Str., 1000 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 810 40 15, +359 2 810 40 18","%acf_bas_site%":"<a href=\"http://www.iki.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.iki.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/11/logo_2010_B-254x300.jpg\" alt=\"\" width=\"254\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he mission of the Economic Research Institute (ERI) of BAS</strong> is to support the economic development and successful integration of Bulgaria into the EU through research, assessments and proposals on the economic policy of the state and business as well as training of scientists and specialists.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Research activity</h6>\r\n<p style=\"text-align: justify;\">In accordance with the Institute's research program, the theoretical and applied research is focused on five main priority areas: competitive and sustainable economic development; sectoral and regional development; economy and management of the company; labor market, social protection and human capital; economic integration in the EU, opportunities and challenges of Bulgaria's participation in the world economy.</p>\r\n<p style=\"text-align: justify;\">Scientific-applied projects under contracts with ministries, agencies, state bodies, non-governmental organizations and companies are being implemented. Strategic documents are developed, expert and consultancy services are provided, analyses and surveys are carried out and objective and independent assessments and opinions are delivered, trainings for the state and non-governmental sectors, the businesses and social partners are held.</p>\r\n<p style=\"text-align: justify;\">There are international projects under contract with European and other foreign and international institutions and programs. The Institute maintains a wide partnership network with similar organizations from Europe, the United States, Asia and Africa, and successfully collaborates with a number of academic institutions and universities in the country and abroad, with global, European and national institutions, networks and structures.</p>\r\n<p style=\"text-align: justify;\">The Institute is a center for scientific discussions, organizer, co-organizer and participant in numerous international and national scientific forums. The ERI of BAS has a significant publishing activity: two indexed and referenced journals, an Annual Report, an academic series of monographs and encyclopedic editions, etc.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">The Economic Research Institute of BAS has long traditions and is a recognized center for the preparation of Bulgarian and foreign specialists in seven doctoral programs: Political Economy; National economy (including regional economy and history of national economy); Finance, Money circulation, credit and insurance; Statistics and Demography; World Economy and International Economic Relations; Economy and Management; Marketing.</p>\r\n<p style=\"text-align: justify;\">The Institute organizes a specialized course for PhD students on \"Methodology of Scientific Research\" designed to provide the methodological and methodical basis necessary for the development of doctoral theses.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Brief history</h6>\r\n<p style=\"text-align: justify;\">The Economic Research Institute was established as an independent specialized unit of BAS in the field of economic science and research in 1949. Currently, it is the leading national academic center in the field of economic science in Bulgaria and has the highest rating in the field of social sciences at BAS received by the external international evaluation of the Federation of All European Academies and the European Science Foundation in 2009. It is among the first 10% leading economic institutes in the world by publications and citations, registered in international databases and the network for dissemination of scientific publications in the field of economics RePEc.</p>\r\n<p style=\"text-align: justify;\">Scientists with rich expertise in research, education, administration and state and business management, well known in the academic community at home and abroad, winners of state awards and distinctions including four academicians and four corresponding members of BAS such as Academician Ivan Stefanov, founder of the unit, and Academician Evgeni Mateev have been working at the Institute.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Economic Research Institute","post_link":"https://www.bas.bg/?page_id=24518&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Economic Research Institute\" width=\"254\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/11/logo_2010_B-254x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.69495020000001","%_wpgmp_metabox_longitude%":"23.327629800000068","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Economic Research Institute","%acf_bas_fax%":"+359 2 988 21 08","%acf_bas_email%":"<a href=\"mailto:ineco@iki.bas.bg\">ineco@iki.bas.bg</a>","%acf_bas_latitude%":"42.69495020000001","%acf_bas_longtitude%":"23.327629800000068","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%pyre_wooslider%":"","%_oembed_728d1e788b4a3f059272b7ec2d1056fa%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.iki.bas.bg","%_gallery_link_target%":"_blank","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":567,\"to_translate\":{\"en\":567}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16847","%_edit_lock%":"1563111908:18","%_edit_last%":"18","%pyre_demo_slider%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_last_translation_edit_mode%":"native-editor","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443047","%avada_post_views_count%":"605","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24518,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Central Laboratory of Solar Energy and New Energy Sources","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Central Laboratory of Solar Energy and New Energy Sources\" width=\"300\" height=\"216\" src=\"https://www.bas.bg/wp-content/uploads/2017/10/SENES_Logo-300x216.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Central Laboratory of Solar Energy and New Energy Sources</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 72 Tsarigradsko shosse Blvd., 1784 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 877 84 48</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.senes.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.senes.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24172&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.651016","lng":"23.387278","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24172&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"72 Tsarigradsko shosse Blvd., 1784 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 877 84 48","%acf_bas_site%":"<a href=\"http://www.senes.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.senes.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/10/SENES_Logo-300x216.jpg\" alt=\"\" width=\"300\" height=\"216\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Central Laboratory of Solar Energy and New Energy Sources (CL SENES) </strong>is a research center for fundamental and applied research in the field of solar energy transformation in Bulgaria.</p>\r\n<p style=\"text-align: justify;\">CL SENES \u2013 BAS was founded with a decree of the Council of Ministers of Bulgaria dated 01.07.1977. The new scientific unit was organized on the basis and a part of the staff and facilities of the Institute of Solid State Physics (ISSP \u2013 BAS) with a decision of the Scientific Council of ISSP of 10.11.1977.</p>\r\n<p style=\"text-align: justify;\">Since January 1978, CL SENES has begun to function as an independent research unit within the Unified Center of Physics. After the structural reform at the Bulgarian Academy of Sciences in 2010, CL SENES received, according to Art. 6 of the Statute of BAS, the status of a Specialized Academy Unit (SAU) within the framework of the Autonomous Research Units (ARU) with budget subsidy.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Research and applied activity</h6>\r\n<p style=\"text-align: justify;\">The main areas of work of scientists at CL SENES are renewable energy sources (RES) and energy efficiency (EE) as well as innovative technologies, materials and semiconductor devices for RES application.</p>\r\n<p style=\"text-align: justify;\">A team of CL SENES is working on the project \u201cIndustrial Development of Water Flow Glazing Systems, (InDeWaG)\u201d funded under Horizon 2020, in conformity with the National Development Programme BG2020 under sub-priority 7.2 \"Enhancement of energy efficiency\".\r\nAn innovative facade with water flow glazing system has been developed, which is a technical innovation of a new building envelope system for Nearly Zero-Energy Buildings. Its industrial application will be demonstrated by the construction of a pavilion in the yard of Science Complex 2 at BAS. It is expected to meet national benchmarks for nearly zero-energy buildings by using the innovative facade technology for the first time in Europe.</p>\r\n<p style=\"text-align: justify;\">The team of CL SENES - BAS under the project \"From marginal to renewable energy sources sites\" (M2RES), implemented under the European Regional Development Fund program for the countries of Southeastern Europe, studied 151 deserted and abandoned sites in Bulgaria and, on the basis of it, developed a National map of the data from the Regional Inspectorates of Environment and Waters as well as from the Ministry of Economy and Energy. The results have shown that even a small fraction, 0.0014% of the territory of the whole country which is abandoned, can provide ~ 900 GWh of electricity per year from renewable energy sources (RES) to power more than 61 600 households. The map is active at <a href=\"http://www.senes.bas.bg\" target=\"_blank\" rel=\"noopener noreferrer\">www.senes.bas.bg</a>.</p>\r\n<p style=\"text-align: justify;\">The New Polymeric Photovoltaic Structures Laboratory develops solar photo elements based on polymeric thin films that have been attracting scientists' interest in recent years. This is caused by the ability to produce cells by cheap technologies from non-expensive, non-toxic materials made up of widespread chemical elements, including on flexible support structures.</p>\r\n<p style=\"text-align: justify;\">The Laboratory of Electrochemical Technologies and Renewable Energy Converters is conducting research on the sample formation of photovoltaic photoelements. New compounds of the type 1,3,5 triazines and carbazoles with a propellant structure have been obtained and tested for use as p-type conductors in the test samples. New compounds with improved solubility and electrophysical performance are expected to produce more effective photoelements.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Doctoral programs:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Electrical, magnetic and optical properties of condensed matter</li>\r\n \t<li>Technology of semiconductor materials and electronic elements</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">Other educational initiatives:</p>\r\n\r\n<ul>\r\n \t<li style=\"text-align: justify;\">Mentors to the MES project \"Student Practices - Phase 1\", funded by OP SESG</li>\r\n \t<li style=\"text-align: justify;\">Universitry teachers at higher education institutions</li>\r\n</ul>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Central Laboratory of Solar Energy and New Energy Sources","post_link":"https://www.bas.bg/?page_id=24172&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Central Laboratory of Solar Energy and New Energy Sources\" width=\"300\" height=\"216\" src=\"https://www.bas.bg/wp-content/uploads/2017/10/SENES_Logo-300x216.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.651016","%_wpgmp_metabox_longitude%":"23.387278","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"9\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Central Laboratory of Solar Energy and New Energy Sources","%acf_bas_fax%":"+359 2 875 40 16","%acf_bas_email%":"<a href=\"mailto:marushka@phys.bas.bg\">marushka@phys.bas.bg</a>","%acf_bas_latitude%":"42.651016","%acf_bas_longtitude%":"23.387278","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_oembed_820ac95f42c6e295651cd7388f105d79%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.senes.bas.bg","%_gallery_link_target%":"_blank","%pyre_wooslider%":"","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":626,\"to_translate\":{\"en\":626}}","%_wpml_media_featured%":"1","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16766","%_edit_lock%":"1562773884:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443013","%avada_post_views_count%":"692","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24172,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Academic Specialized Unit","id":"9","type":"category"}]},{"source":"post","title":"Cyrillo-Methodian Research Center","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Cyrillo-Methodian Research Center\" width=\"141\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/10/Logo_CMRS-141x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Cyrillo-Methodian Research Center</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 13 Moskovska Str., 1000 Sofia</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 987 02 61</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.kmnc.bg\" target=\"_blank\" rel=\"noopener\">www.kmnc.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24512&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.696970","lng":"23.327790","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24512&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"13 Moskovska Str., 1000 Sofia","%acf_bas_phone%":"+359 2 987 02 61","%acf_bas_site%":"<a href=\"http://www.kmnc.bg\" target=\"_blank\" rel=\"noopener\">www.kmnc.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/10/Logo_CMRS-141x300.jpg\" alt=\"\" width=\"141\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Cyrillo-Methodian Research Center at the Bulgarian Academy of Sciences (CMRC)</strong> is a specialized scientific unit within the scientific division \"Cultural-Historical Heritage and National Identity\" oriented towards a complex study of the work of the creators of the Slavonic writing, St. Cyril and St. Methodius, and its influence on Bulgarian and European culture.</p>\r\n<p style=\"text-align: justify;\">Basic research is complemented by active training activities. In pursuit of its mission, CMRC develops a wide range of multidisciplinary research (linguistic, literary, palaeographic, codicological, theological, historical, cultural, etc.) related to all aspects of the Cyrillo-Methodian work, which is of big significance for the overall historical path of Bulgaria and is one of the most important factors for the safeguarding of the national identity of the Bulgarian people. Its safeguarding and development is also the greatest contribution of Bulgarians in the European and world written culture.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Research activity</h6>\r\n<p style=\"text-align: justify;\">The main results and achievements of CMRC activities are in line with the priorities set in the perspective of the Strategy for the Development of Science in Bulgaria:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Search for and complex study of Cyrillo-Methodian sources in medieval manuscripts from IX to XVI centuries and Old printed books, kept in Bulgarian and foreign libraries and published Slavic, Greek, Latin and Roman-German sources;</li>\r\n \t<li>Complex study of the Cyrillo-Methodian traditions from IX century to present-day in Bulgaria and in Europe;</li>\r\n \t<li>Study of the Slavic writing as a system and its functioning in Europe since its emergence to the present day; 4. Popularization of the Cyrillo-Methodian work and traditions to the benefit of the Bulgarian society as part of building of a new European Knowledge society;</li>\r\n \t<li>Safeguarding and socialization of the Bulgarian mediaeval heritage through the tools of digital humanities - the digital repository \"Cyrillo-Methodian Cultural Heritage\" (<a href=\"http://repository.kmnc.bg/\">http://repository.kmnc.bg/</a>) has been created;</li>\r\n \t<li>Expert advice to the Bulgarian state and public institutions in relation to cultural phenomena in the sphere of Cyrillo-Methodian studies and the international acceptance of the scientific truth regarding the controversial problems of the Cyrillo-Methodian work;</li>\r\n \t<li>Publication of the research results of CMRC scholars in prestigious humanitarian periodicals and monographs in the country and abroad.</li>\r\n</ul>\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">CMRC is accredited for PhD students training in three programs:</p>\r\n<p style=\"text-align: justify;\">2.1. Philology: Theory and History of Literature</p>\r\n<p style=\"text-align: justify;\">2.1. Philology: Bulgarian Literature</p>\r\n<p style=\"text-align: justify;\">2.1. Philology: Bulgarian Language</p>\r\n<p style=\"text-align: justify;\">Number of PhD students: 3, 1 postdoctoral student</p>\r\n<p style=\"text-align: justify;\">Besides the training of PhD students, the Center provides a different type of specialization in Cyrillo-Methodian Studies: it trains PhD students and trainees under Erasmus+; its research associates are lecturing as guest lecturers at prestigious universities abroad as well as in the Training Center of BAS and Bulgarian universities.</p>\r\n<p style=\"text-align: justify;\">A project in support of teachers and students: \"Video-lecture courses on Cyrillo-Methodian Studies\" (in collaboration with Publishing House \"Prosveta\").</p>\r\n\r\n<h6 style=\"text-align: justify;\">History of the unit</h6>\r\n<p style=\"text-align: justify;\">The Cyrillo-Methodian Research Center is the successor of a centuries-old research tradition at BAS, devoted to the study of the oldest, Cyrillo-Methodian period in the history of Slavonic literature and the related phenomena and artifacts. At its very beginning, it was the Clement Committee set up in 1914. The results of its activities became the basis for the establishment of a Commission for the Publishing of the Cyrillo-Methodian Sources (the so called Cyrillo-Methodian Commission) at BAS by decision of IV International Congress of Byzantine Studies in 1934. Having existed until 1944, the Cyrillo-Methodian Commission was restored only in 1971, comprising two scientific associates under the chairmanship of corr.-mem. Prof. Kiril Mirchev. In 1980, it merged with the newly-founded Cyrillo-Methodian Research Center, the first director of which was Academician Prof. Petar Dinekov. With the extension of scientific research and laying the foundations for complex studies of the Cyrillo-Methodian work, the staff of the Center was also expanding. In connection with the restructuring of BAS in 1994, the Section for the Publishing of Old Bulgarian Texts, led by Assoc. Prof. E. Dogramadjieva from the Institute for Bulgarian Language at BAS was transferred to it as well as individual scientists from the Institutes for Balkan studies and Art Studies.</p>\r\n<p style=\"text-align: justify;\">Over the years, Academician Petar Dinekov, Prof. DSc Ekaterina Dogramadjieva, Prof. Svetlina Nikolova, Prof. Vasilka Tapkova-Zaimova, Prof. DSc Boryana Velcheva, Assoc. Prof. Dr. Elena Kotseva, Prof. Dr. Klimentina Ivanova, Prof. Dr. Lilyana Mavrodinova, Prof. DSc Lora Taseva, Prof. DSc Maria Yovcheva have been working at the institutions whose successor is CMRC.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Cyrillo-Methodian Research Center","post_link":"https://www.bas.bg/?page_id=24512&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Cyrillo-Methodian Research Center\" width=\"141\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/10/Logo_CMRS-141x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.696970","%_wpgmp_metabox_longitude%":"23.327790","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"9\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Cyrillo-Methodian Research Center","%acf_bas_fax%":"+359 2 986 69 62","%acf_bas_email%":"<a href=\"mailto:kmnc@kmnc.bg\">kmnc@kmnc.bg</a>, <a href=\"mailto:kmnc@bas.bg\">kmnc@bas.bg</a>","%acf_bas_latitude%":"42.696970","%acf_bas_longtitude%":"23.327790","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpmf_gallery_custom_image_link%":"http://www.kmnc.bg","%_gallery_link_target%":"_blank","%pyre_wooslider%":"","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":743,\"to_translate\":{\"en\":743}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16749","%_edit_lock%":"1563111024:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443047","%avada_post_views_count%":"324","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24512,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Academic Specialized Unit","id":"9","type":"category"}]},{"source":"post","title":"National Institute of Geophysics, Geodesy and Geography","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Institute of Geophysics, Geodesy and Geography\" width=\"291\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/10/logo_NIGGG-291x300.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">National Institute of Geophysics, Geodesy and Geography</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 3, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 3322</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.niggg.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.niggg.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24436&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.67623589999999","lng":"23.369488700000034","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24436&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 3, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 3322","%acf_bas_site%":"<a href=\"http://www.niggg.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.niggg.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/10/logo_NIGGG-291x300.png\" alt=\"\" width=\"291\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he National Institute of Geophysics, Geodesy and Geography (NIGGG) </strong>was founded on 01.07.2010 by merging the following research units of the Bulgarian Academy of Sciences:</p><ul style=\"text-align: justify;\"><li>Geophysical Institute (1960),</li><li>Geographical Institute (1950),</li><li>Central Laboratory of Higher Geodesy (1948) and</li><li>Central Laboratory of Seismic Mechanics and Seismic Engineering (1982).</li></ul><p style=\"text-align: justify;\">Their founders are the distinguished Bulgarian scientists of world renown: Academician Lyubomir Krastanov (1908-1977), corr.-mem. Zhivko Gulubov (1908-1993), Academician Vladimir Hristov (1902-1979), Academician Georgi Brankov (1913-1997).</p><p style=\"text-align: justify;\">The National Institute of Geophysics, Geodesy and Geography performs fundamental and applied research in geophysics, seismology, seismic mechanics, seismic engineering, geodesy and geography.</p><p style=\"text-align: justify;\">The Institute provides Bulgarian state and society with operational, monitoring and expert information and training of specialists. These activities are aimed entirely in favour of the sustainable development of society based on knowledge and is carried out in five departments: \u201cGeophysics\u201d, \u201cSeismology\u201d, \u201cSeismic Engineering\u201d, \u201cGeodesy\u201d and \u201cGeography\u201d.</p><p style=\"text-align: justify;\">The National Institute of Geophysics, Geodesy and Geography at BAS operates and maintains one-of-a-kind national monitoring networks such as:</p><ul style=\"text-align: justify;\"><li>National Seismological Service;</li><li>National Strong Earth Motion Network;</li><li>National Network of Permanent Global Navigation Satellite System (GPS/GNSS) Stations;</li><li>National Mareographic Network for monitoring the level of the Black Sea;</li><li>National Geomagnetic Service with Geomagnetic Observatory;</li><li>National Ionospheric Service;</li><li>The Network for Terrestrial Measurements of Biologically Active Solar Ultraviolet Radiation;</li><li>Forecasting System for the Levels of the Tropospheric Ozone in the Atmosphere.</li></ul><p style=\"text-align: justify;\">An integral part of the research infrastructure of NIGGG is:</p><ul style=\"text-align: justify;\"><li>National Geomagnetic Observatory Panagyurishte;</li><li>Paleomagnetic Laboratory;</li><li>National Geodetic Observatory in Plana;</li><li>Geographic Information Center.</li></ul><h6 style=\"text-align: justify;\">Priorities</h6><ol><li style=\"text-align: justify;\">Development of scientific methods and tools for research and operational activities;</li><li style=\"text-align: justify;\">Monitoring of processes and phenomena related to natural and anthropogenic risks;</li><li style=\"text-align: justify;\">Investigation of seismic risk and the risk of other disasters, modern earth crust movements, as well as the resilience of buildings, engineering facilities and infrastructure;</li><li style=\"text-align: justify;\">Disclosure of risk events and formation of science-based policies in the management of natural and anthropogenic risks;</li><li style=\"text-align: justify;\">Geographic research of the nature, population, socio-economic and regional development of Bulgaria;</li><li style=\"text-align: justify;\">Linking research to the needs of state, public and business organizations in order to implement scientific results in practice;</li><li style=\"text-align: justify;\">Participation in European and global research programs and monitoring networks;</li><li style=\"text-align: justify;\">Attracting and training young professionals.</li></ol>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]International relations[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\nMagNetE\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nEU-TecNet\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nBGSpeleo-RadNet\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nProKARSTerra\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nBIOMRTNET\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]<p>ESNET \u2013 BlackSeaEarthquakeSafetyNet</p>[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nCEEPUS \u2013 Applied Geoinformatics (SEE_GIS)\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nGLOCAD \u2013 Global Change Atlas of Danube Region\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nMRI-Europe \u2013 Mountain Research Initiative\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"National Institute of Geophysics, Geodesy and Geography","post_link":"https://www.bas.bg/?page_id=24436&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Institute of Geophysics, Geodesy and Geography\" width=\"291\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/10/logo_NIGGG-291x300.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_2806f6495db8d7eaddf7541a4b86d3b3%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.niggg.bas.bg","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.67623589999999","%_wpgmp_metabox_longitude%":"23.369488700000034","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%pyre_wooslider%":"","%acf_bas_deptname%":"National Institute of Geophysics, Geodesy and Geography","%acf_bas_fax%":"+359 2 971 3005","%acf_bas_email%":"<a href=\"mailto:office@geophys.bas.bg\">office@geophys.bas.bg</a>","%acf_bas_latitude%":"42.67623589999999","%acf_bas_longtitude%":"23.369488700000034","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":502,\"to_translate\":{\"en\":502}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16620","%_edit_lock%":"1563017016:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443040","%avada_post_views_count%":"907","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24436,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Central Laboratory of Applied Physics &#8211; Plovdiv","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Central Laboratory of Applied Physics &#8211; Plovdiv\" width=\"300\" height=\"233\" src=\"https://www.bas.bg/wp-content/uploads/2017/10/CLAP_Photos-300x233.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Central Laboratory of Applied Physics &#8211; Plovdiv</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 61 Sankt Peterburg Blvd., 4000 Plovdiv, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 32 635019</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.clap-bas.com\" target=\"_blank\" rel=\"noopener\">http://www.clap-bas.com</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24285&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.138843","lng":"24.7730134","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24285&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"61 Sankt Peterburg Blvd., 4000 Plovdiv, Bulgaria","%acf_bas_phone%":"+359 32 635019","%acf_bas_site%":"<a href=\"http://www.clap-bas.com\" target=\"_blank\" rel=\"noopener\">http://www.clap-bas.com</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><a href=\"https://www.bas.bg/wp-content/uploads/2017/10/logo_clap.jpg\"><img class=\"alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2017/10/logo_clap-300x207.jpg\" alt=\"\" width=\"300\" height=\"207\" /></a>[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Central Laboratory of Applied Physics - Plovdiv (CLAP)</strong> conducts scientific, applied research, development and innovative transfer in the field of materials and technologies, including nanomaterials and nanotechnologies, and in the field of energy efficiency.</p><p style=\"text-align: justify;\">The Central Laboratory of Applied Physics was established on April 1, 1979 as a Laboratory of Applied Physics at BAS. In 1984, an experimental production was launched, based on which a Small Enterprise for Sensors and Sensor Devices was set up in October 1986. In 1986, LAP was transformed into the Institute of Applied Physics, and in 1995 - into the Central Laboratory of Applied Physics. In 2009, a Center for High Technology was established at CLAP.</p><p style=\"text-align: justify;\">CLAP was established as a unit of BAS conducting scientific and applied research in the field of microelectronics and optoelectronics, incl. development of III-V semiconductor materials, sensors and sensor devices on their basis.</p><h6 style=\"text-align: justify;\">Research and innovation activity</h6><p style=\"text-align: justify;\">The main areas in which the scientific and applied activity in CLAP is carried out are:<br />\u2022 Innovative nanostructured and nano-sized layers for surface modification for industrial and biomedical applications.<br />\u2022 New semiconductor materials and structures high-efficiency solar cells and modules for charging electric vehicles.<br />\u2022 Energy-saving and ecological LED systems for organic farming, lighting, signaling and monitoring.</p><p style=\"text-align: justify;\">CLAP performs an innovative transfer to companies from the country and Europe of:</p><ul style=\"text-align: justify;\"><li>Hard wear-resistant coatings to extend the operating time of tools for the metalworking industry.</li><li>Super-hard high-temperature and wear resistant coatings for \"dry\" machining.</li><li>Technologies and equipment for electrolytic and plasma polishing of stainless steel, aluminum and aluminum alloy parts.</li><li>Highly efficient energy-saving RGB LED systems for greenhouse applications.</li><li>Autonomous energy-saving stations working on the basis of alternative energy sources with application in organic farming.</li></ul><blockquote><p style=\"text-align: justify;\">In 2004, the CLAP was awarded the Marine Drinov Honorary Plaque for scientific and applied research and their implementation in the development and production of sensors and sensor devices.</p><p style=\"text-align: justify;\">In 2015, the CLAP was awarded the Golden Stamp for European Management in Science and Golden Badge for contribution to the development of Bulgarian science.</p></blockquote><p style=\"text-align: justify;\">The most significant achievements of CLAP after 2010 are:</p><ul style=\"text-align: justify;\"><li>A high-tech scientific research complex was built for the development and characterization of innovative materials for surface modification by nanostructured and nanosized coatings and thin layers.</li><li>Monolayer and multilayer hard wear-resistant coatings of nitrides, carbides and carbonitrides of transition metals with temperature stability up to 700\u00b0C were created and transferred to industry.</li><li>Ultra-hard mono-layer and multi-layer nanocomposite coatings, stable up to 900\u00b0C, and increasing the time of use of tools by 60% were created, some of which transferred to the metalworking industry.</li><li>Low-temperature technologies (below 200\u00b0C) for monolayer and multilayer (with nanosized period) nitride coatings with low friction and wear ratio and high corrosion resistance in aggressive environments were developed for industrial applications on specialized low-temperature steels, plastics and for medical applications on dentures, implants and more.</li><li>Multi-component compounds based on III-V dilute nitrides have been developed with high structural perfection and extended spectral IR photosensitivity for use in multijunction highly efficient solar cells.</li><li>Equipment and environmentally-friendly technology for electrolytic and plasma modification through polishing and oxidation of surfaces made of stainless steel and aluminum were developed.</li><li>An autonomous energy system based on alternative sources provided with remote control via an on-line connection was created. The system is multiplied to provide electrical power to sites away from standard power supply and urban areas.</li></ul><h6 style=\"text-align: justify;\">Educational activity</h6><p style=\"text-align: justify;\">CLAP is accredited for the training of PhD students under the code 01.03.26 \"Electrical, magnetic and optical properties of condensed matter\".</p><p style=\"text-align: justify;\">CLAP works together with Plovdiv University Paisii Hilendarski and the Technical University of Plovdiv in the preparation of Bachelor, Master, Graduate and Doctoral students.</p><p style=\"text-align: justify;\">CLAP is the organizer of the NANOHARD International Conferences on \"Nanostructured Materials, Thin Layers and Solid Coatings for Contemporary Applications\".</p><p style=\"text-align: justify;\">Other significant achievements of CLAP:</p><ul><li style=\"text-align: justify;\">Within the framework of 4 European projects under COPERNICUS, NATO SfP and INTAS programmes, powerful, high-frequency and high-temperature SiC MESFETs; powerful high temperature SiC p-n diodes and high-temperature, high-frequency and high-voltage SiC p-i-n diodes have been developed. Ohmic and Schottky contacts have been developed for these devices, stable at temperatures up to 600\u00b0C. Powerful (over 100 W), high frequency (10 GHz) and high temperature (300\u00b0C) housings for SiC MESFETs and powerful diodes have been designed and manufactured.</li><li style=\"text-align: justify;\">A3B5 heterostructures have been developed and implemented for use in multijunction solar cells.</li><li style=\"text-align: justify;\">A wide range of photo-, magneto-, thermo-, radiation sensitive and capacitance sensors, as well as sensor units on their basis have been developed and implemented. Microwave sensors, photo probes and gamma LEDs are produced.</li><li style=\"text-align: justify;\">Based on Peltier modules, an isothermal container for the storage and transport of blood and a mini-refrigerator have been developed and manufactured. These products were awarded with a gold medal at the 55th International Fair Plovdiv and Silver Plaque at the International Exhibition \"Makinova 2003\" in Macedonia.</li></ul>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Central Laboratory of Applied Physics &#8211; Plovdiv","post_link":"https://www.bas.bg/?page_id=24285&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Central Laboratory of Applied Physics &#8211; Plovdiv\" width=\"300\" height=\"233\" src=\"https://www.bas.bg/wp-content/uploads/2017/10/CLAP_Photos-300x233.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.138843","%_wpgmp_metabox_longitude%":"24.7730134","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"9\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%pyre_wooslider%":"","%_oembed_10f91c9ded314aaf5d1e74f8d0897a95%":"{{unknown}}","%acf_bas_deptname%":"Central Laboratory of Applied Physics - Plovdiv","%acf_bas_fax%":"+359 32 632810","%acf_bas_email%":"<a href=\"mailto:clapbas@mbox.digsys.bg\">clapbas@mbox.digsys.bg</a>","%acf_bas_latitude%":"42.138843","%acf_bas_longtitude%":"24.7730134","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpmf_gallery_custom_image_link%":"http://www.clap-bas.com/","%_gallery_link_target%":"","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":850,\"to_translate\":{\"en\":850}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16609","%_edit_lock%":"1562773801:18","%_edit_last%":"18","%pyre_demo_slider%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_last_translation_edit_mode%":"native-editor","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443025","%avada_post_views_count%":"536","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24285,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Academic Specialized Unit","id":"9","type":"category"}]},{"source":"post","title":"Center for National Security and Defense Research","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Center for National Security and Defense Research\" width=\"210\" height=\"74\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/cnsdr_logo.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Center for National Security and Defense Research</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 26B, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 2014, +359 2 979 5228</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.cnsdr.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.cnsdr.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24621&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.673509","lng":"23.365096","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24621&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 26B, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 2014, +359 2 979 5228","%acf_bas_site%":"<a href=\"http://www.cnsdr.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.cnsdr.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"1\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"none\" sep_color=\"\"][acf field=\"acf_bas_deptname\"][/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/cnsdr_logo.png\" alt=\"\" width=\"210\" height=\"74\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]h<strong>e Center for National Security and Defense Research (CNSDR)</strong>, founded in 2002, assists, coordinates, and organizes security and defense research within the Bulgarian Academy of Sciences. The Center's activities are focused on providing information to the institutes and laboratories of BAS, research groups and individual scientists about the needs and programs of potential end-users, the opportunities for bilateral and multilateral cooperation within NATO and the European Union.</p>\r\n<p style=\"text-align: justify;\">In parallel with its co-ordination activities, CNSDR organizes, conducts, participates and performs large-scale interdisciplinary research, the most important of which are:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Force Modernisation Study, conducted for the Ministry of Defense in 2002;</li>\r\n \t<li>A Study on the Restructuring of TEREM EAD (major Bulgarian state owned defence company), conducted for the Ministry of Defense and TEREM EAD in 2003;</li>\r\n \t<li>White Paper on Civil Security, conducted for the Permanent Government Committee for Protection of the Population in Emergencies in 2004;</li>\r\n \t<li>Methodology for Planning of Critical Infrastructure Protection, conducted for the Permanent Government Committee for Protection of the Population in Emergencies at the Council of Ministers in 2005;</li>\r\n \t<li>EU TACOM \u2013 2006: Exercise for Terrorist Act Consequences Management, a project funded by Directorate-General \u201cEnvironment\u201d of the European Commission in 2006;</li>\r\n \t<li>Methodology for Critical Infrastructure Protection at Municipal Level \u2013 developed within the framework of a public tender for the Ministry of State Policy for Disasters and Accidents in 2007;</li>\r\n \t<li>Participation in Saber Guardian 14, a multinational practical exercise designed to optimize the capabilities and commitments of the American Army in Europe in order to achieve greater flexibility, preservation and enhancement of NATO interoperability as well as facilitating multinational training;</li>\r\n \t<li>Establishment of a specialized Aero-Space Technology Transfer Office for Crisis Management and Disaster Resilience in the Field of Protection of Citizens' Health. The project was funded by the Operational Program \"Development of the Competitiveness of the Bulgarian Economy\" 2007-2013. The Technology Transfer Office is a participant in the Bulgarian Technology Transfer Network and takes part in various initiatives, conferences, symposia, forums, workshops, etc.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">In these studies, CNSDR attracts the best Bulgarian scientists and researchers from BAS, other research organizations and universities and in fact serves as the National Center for Security and Defense Studies Coordination.</p>\r\n<p style=\"text-align: justify;\">The Center also functions to provide national teams with information on the launching of the EU's Seventh Framework Program on the thematic area \"Security\". The Director of the Center is a member of the Security Programming Committee of the 7th Framework Program, and an expert from the Center is a National Contact Person on Priority Security. The CNSDR Director is a national representative of the NATO Scientific Committee, and a scientist from the Center is a member of the NATO Research and Technology Board.</p>\r\n<p style=\"text-align: justify;\">CNSDR regularly organizes a national competition under the motto \"Scientific support for the security sector transformation\" and a national conference \"Protection of the population and critical infrastructure\".</p>\r\n<p style=\"text-align: justify;\">Reports of conferences and competitions are published in specialized collections. In addition, CNSDR, together with Sofia Security Forum, organizes seminars and roundtables (3-4 times a year) devoted to current security issues on a global and national scale.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker-alt fas\"][acf field=\"acf_bas_address\"][/fusion_li_item][fusion_li_item icon=\"fa-phone-square fas\"][acf field=\"acf_bas_phone\"][/fusion_li_item][fusion_li_item icon=\"fa-fax fas\"][acf field=\"acf_bas_fax\"][/fusion_li_item][fusion_li_item icon=\"fa-at fas\"][acf field=\"acf_bas_email\"][/fusion_li_item][fusion_li_item icon=\"fa-sitemap fas\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Center for National Security and Defense Research","post_link":"https://www.bas.bg/?page_id=24621&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Center for National Security and Defense Research\" width=\"210\" height=\"74\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/cnsdr_logo.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_5b705c9f5d6a2ddabc1e97673eed8f66%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.cnsdr.bas.bg/","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.673509","%_wpgmp_metabox_longitude%":"23.365096","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Center for National Security and Defense Research","%acf_bas_fax%":"+359 2 981 6629","%acf_bas_email%":"<a href=\"mailto:cnsdr@bas.bg\">cnsdr@bas.bg</a>","%acf_bas_latitude%":"","%acf_bas_longtitude%":"","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpml_word_count%":"{\"total\":618,\"to_translate\":{\"en\":618}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_oembed_2abb5409968ca26f8f17ad977f2819aa%":"{{unknown}}","%_oembed_7087c925132b7544438318a5caa4a6b0%":"{{unknown}}","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_thumbnail_id%":"24619","%_edit_lock%":"1563199798:18","%_edit_last%":"18","%pyre_demo_slider%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_last_translation_edit_mode%":"native-editor","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443062","%avada_post_views_count%":"1284","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","%_fusion_google_fonts%":"","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24621,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Specialized Unit","id":"8","type":"category"}]},{"source":"post","title":"Joint Innovation Centre of BAS","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Joint Innovation Centre of BAS\" width=\"128\" height=\"128\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/logo_EIC_square.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Joint Innovation Centre of BAS</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 26B, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 971 47 23</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.jic-bas.eu/\" target=\"_blank\" rel=\"noopener\">http://www.jic-bas.eu/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24614&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.673509","lng":"23.365096","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24614&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 26B, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 971 47 23","%acf_bas_site%":"<a href=\"http://www.jic-bas.eu/\" target=\"_blank\" rel=\"noopener\">http://www.jic-bas.eu/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"1\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"none\" sep_color=\"\"][acf field=\"acf_bas_deptname\"][/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/logo_EIC.png\" alt=\"\" width=\"128\" height=\"150\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Joint Innovation Centre</strong> is a coordination unit for implementing the policy of BAS in the fields of:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>innovation and</li>\r\n \t<li>patent activities</li>\r\n \t<li>project competence.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The Centre provides information for applying in answer of EU Structural Funds and the Framework Programme of EU \u201cHorizon 2020\u201d calls; supports the preparation and implementation of project proposals. The Centre maintains business contacts in the country and abroad concerning innovations and applied research transfer and supports the establishment of contacts \u201cscience \u2013 business\u201d and \u201cscience \u2013 science\u201d.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Achievements</h6>\r\n<p style=\"text-align: justify;\">In 2007, a classification of innovative research was established and, as a result, a methodology for annual reporting and evaluation of innovations at the units of the Bulgarian Academy of Sciences. To obtain results, the number of innovations is compared to the funding received (from the budget and from projects) and to the research staff employed. Thus an assessment of relative efficiency at the academic units is obtained.</p>\r\n<p style=\"text-align: justify;\">In the period 2012-2015, the Joint Innovation Center gave 452 consultations to researchers and external business partners; in Enterprise Europe Network, 144 applied developments were uploaded while interest was expressed in 104 of them; 123 technology offers were prepared and, as a result, 64 partnership agreements were concluded; 49 projects were prepared; 38 workshops, with 1263 participants, were held; 180 patent and utility models applications were submitted, and 45 were registered.</p>\r\n<p style=\"text-align: justify;\">In 2011, a technology transfer office \"Proinno\" was set up, aiming at the realization of urban ecology and energy saving technologies. Its goals are:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>transfer of innovative applied research products;</li>\r\n \t<li>consultancy and information services;</li>\r\n \t<li>building a virtual office/library;</li>\r\n \t<li>conducting seminars on administrative and expert capacity;</li>\r\n \t<li>assistance with the participation in national and European programs with a focus on Horizon 2020.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">By the end of 2016, the goals were achieved, and the office has continued its work beyond 2018.</p>\r\n<p style=\"text-align: justify;\">JIC has two conference halls (65 and 30 seats) at the disposal of the units of BAS.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker-alt fas\"][acf field=\"acf_bas_address\"][/fusion_li_item][fusion_li_item icon=\"fa-phone-square fas\"][acf field=\"acf_bas_phone\"][/fusion_li_item][fusion_li_item icon=\"fa-fax fas\"][acf field=\"acf_bas_fax\"][/fusion_li_item][fusion_li_item icon=\"fa-at fas\"][acf field=\"acf_bas_email\"][/fusion_li_item][fusion_li_item icon=\"fa-sitemap fas\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Joint Innovation Centre of BAS","post_link":"https://www.bas.bg/?page_id=24614&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Joint Innovation Centre of BAS\" width=\"128\" height=\"128\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/logo_EIC_square.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_202ec4efb8e86d278794a2c4bee19ab3%":"{{unknown}}","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.673509","%_wpgmp_metabox_longitude%":"23.365096","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Joint Innovation Centre of BAS","%acf_bas_fax%":"+359 2 872 25 44","%acf_bas_email%":"<a href=\"mailto:office@jic.bas.bg\">office@jic.bas.bg</a>","%acf_bas_latitude%":"","%acf_bas_longtitude%":"","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpml_word_count%":"{\"total\":368,\"to_translate\":{\"en\":368}}","%_wpml_location_migration_done%":"1","%_wpml_media_duplicate%":"1","%_wpml_media_featured%":"0","%_oembed_1a6867ed5db14a51727936392e745feb%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.jic-bas.eu/","%_gallery_link_target%":"_blank","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_thumbnail_id%":"16932","%_edit_lock%":"1563198401:18","%_edit_last%":"18","%pyre_demo_slider%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_last_translation_edit_mode%":"native-editor","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443062","%avada_post_views_count%":"604","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24614,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Specialized Unit","id":"8","type":"category"}]},{"source":"post","title":"Bulgarian Encyclopaedia Scientific Information Centre","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bulgarian Encyclopaedia Scientific Information Centre\" width=\"300\" height=\"91\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/be-300x91.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Bulgarian Encyclopaedia Scientific Information Centre</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 4, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 22 90, +359 896 280 488</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.bulg-enc.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.bulg-enc.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24608&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","content":"yes","location":{"lat":"42.676131","lng":"23.370122","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24608&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 4, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 22 90, +359 896 280 488","%acf_bas_site%":"<a href=\"http://www.bulg-enc.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.bulg-enc.bas.bg/</a>","post_excerpt":"yes","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\" type=\"legacy\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"false\" min_height=\"\" hover_type=\"none\" link=\"\" border_sizes_top=\"\" border_sizes_bottom=\"\" border_sizes_left=\"\" border_sizes_right=\"\" first=\"true\" spacing_right=\"2.6666666666666665%\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/be-300x91.jpg\" alt=\"\" width=\"300\" height=\"91\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>B</strong>[/fusion_dropcap]<strong>ulgarian Encyclopaedia Scientific Information Centre</strong> is a unique centre, the only one in the country which is specialized in preparation of encyclopaedias. The editions of Bulgarian Encyclopaedia are at a high academic level: their authors, consultants and contributors are prominent Bulgarian scientists in all fields of knowledge. The editing and compilation work is done by experienced scientific encyclopedic editors which guarantees the high professional level of the editions</p>\r\n<p style=\"text-align: justify;\">The Bulgarian Encyclopedia SC aims and successfully carries out the enlightenment mission of BAS: to present Bulgarian science in popular form to the public.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Main activities</h6>\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Compiles and prepares for publishing general one-volume and multi-volume encyclopaedias;</li>\r\n \t<li>Compiles and prepares for publishing specialized encyclopedias;</li>\r\n \t<li>Compiles and prepares for publishing encyclopaedic reference books;</li>\r\n \t<li>Compiles and prepares for publishing CD and online encyclopaedias;</li>\r\n \t<li>Develops and offers concepts for new editions;</li>\r\n \t<li>Develops methodological guidelines and technologies for editorial work;</li>\r\n \t<li>Prepares the glossaries of the articles and the illustrations of the editions;</li>\r\n \t<li>Carries out editorial and compilation work (ordering the writing of articles by authors, editing authors\u2019 articles, compiling articles, typesetting and editing of illustrative material) while creating a single manuscript and bears responsibility for the scientific shedding of light on problems and the encyclopaedic layout of the editions;</li>\r\n \t<li>Prepares and provides up-to-date information about Bulgaria for foreign encyclopaedias;</li>\r\n \t<li>Provides methodological assistance in the preparation of encyclopaedic reference books from other institutes of BAS;</li>\r\n \t<li>Prepares and maintains an information page for Bulgaria on the Internet.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">Professionally prepared, the encyclopaedias of SC Bulgarian Encyclopaedia have won the trust of a large number of readers and the acknowledged recognition of the cultural community which confirms their utility for the society and the national significance of the activity of SC Bulgarian Encyclopedia.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">The SCBE team continues to actively work on Project BG05M2OP001-2.002-0001, Student Practices \"- Phase 1, funded under the Science and Education for Smart Growth 2014-2020 OP through the European Social Fund of the European Union in partnership with the Ministry of Education and Science and leading higher education institutions in the country.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"true\" border_sizes_top=\"0\" border_sizes_bottom=\"0\" border_sizes_left=\"0\" border_sizes_right=\"0\" first=\"false\" spacing_left=\"1.3333333333333333%\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\" margin_top_small=\"\" margin_bottom_small=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Bulgarian Encyclopaedia Scientific Information Centre","post_link":"https://www.bas.bg/?page_id=24608&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bulgarian Encyclopaedia Scientific Information Centre\" width=\"300\" height=\"91\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/be-300x91.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.676131","%_wpgmp_metabox_longitude%":"23.370122","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Bulgarian Encyclopaedia Scientific Information Centre","%acf_bas_fax%":"+359 2 979 67 24","%acf_bas_email%":"<a href=\"mailto:encyclopedia@mail.bg\">encyclopedia@mail.bg</a>","%acf_bas_latitude%":"42.676131","%acf_bas_longtitude%":"23.370122","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_oembed_82bb17f99a18129e7283b33edd046891%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.znam.bg","%_gallery_link_target%":"_blank","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpml_word_count%":"{\"total\":384,\"to_translate\":{\"en\":384}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_thumbnail_id%":"17121","%_edit_lock%":"1627561570:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"bg_full":"no","display_header":"yes","header_bg_full":"no","show_first_featured_image":"yes","main_padding":{"top":"","bottom":""},"content_bg_full":"no","bg_repeat":"repeat","header_bg_repeat":"repeat","displayed_menu":"default","slider_type":"no","slider":"0","wooslider":"0","page_title_bar":"default","content_bg_repeat":"repeat","pages_sidebar":"","pages_sidebar_2":"","sidebar_sticky":"default"},"%_alp_processed%":"1627559871","%_fusion_google_fonts%":"","%avada_post_views_count%":"529","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24608,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Specialized Unit","id":"8","type":"category"}]},{"source":"post","title":"Scientific Archive of BAS","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Scientific Archive of BAS\" width=\"280\" height=\"180\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/Centralna_biblioteka_BAN.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Scientific Archive of BAS</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 1 \"15 Noemvri\" Str., 1000 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 53 32</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://archiv.cl.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://archiv.cl.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24589&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.694809","lng":"23.332129","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24589&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"1 \"15 Noemvri\" Str., 1000 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 53 32","%acf_bas_site%":"<a href=\"http://archiv.cl.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://archiv.cl.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"1\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"none\" sep_color=\"\"][acf field=\"acf_bas_deptname\"][/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/08/Centralna_biblioteka_BAN.jpg\" alt=\"\" width=\"280\" height=\"180\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Scientific Archive of the Bulgarian Academy of Sciences (SA-BAS)</strong> aims to find, preserve, scientifically and technically process and put to use materials on the history of scientific thought and social life in Bulgaria and to do expertise on their value. It is, essentially, the first national historical archive to carry out these activities and contains valuable documents on the history of the Bulgarian state and people.</p><p style=\"text-align: justify;\">The first steps were made as early as the founding of the Bulgarian Learned Society (BLS) in Braila. One of the Society\u2019s tasks, according to Article 6 of its Statute, has been \"to gradually make collections of various old Bulgarian and foreign books, manuscripts, money and other similar valuables that will constitute an old-world cabinet inexcommunicated by the library.\"</p><p style=\"text-align: justify;\">The newly established learned society was set up on a very broad, democratic, national and at the same time European basis in order to \"disseminate the universal enlightenment of the Bulgarian people and to show the way to its material enrichment\".</p><p style=\"text-align: justify;\">Since 1994, the Scientific Archive of the Bulgarian Academy of Sciences is an independent specialized unit of BAS with a legal entity status. As a management body of the State archives fund on the territory of BAS the Scientific Archive:</p><ul style=\"text-align: justify;\"><li>Collects archival documents from the units of the Bulgarian Academy of Sciences, the personal funds of academicians, corresponding members, professors and associate professors working at the Academy;</li><li>Performs scientific and technical processing, expertise on the value of the archival documents and their restoration;</li><li>Organizes the use of archival documents for research, reference, etc. aims, prepares documentary publications and exhibitions;</li><li>Provides methodological assistance to the units of the Bulgarian Academy of Sciences in the work of their records and archives departments.</li></ul><p style=\"text-align: justify;\">The scientific archive participates in the international microfilm exchange of archival documents, in the preparation of bilateral and multilateral documentary editions, etc.</p><p style=\"text-align: justify;\">In recent years, the SA documents have been actively used by researchers, external readers, mass media and foreigners for references, exhibitions, documentaries, diploma theses, dissertation papers, articles, monographs, scientific reports, and so on.</p><p style=\"text-align: justify;\">Branches of the SA have been created at the National Archaeological Institute with Museum - BAS, the Institute of Art Studies (the SA of IAS-BAS), the Institute of Ethnology and Folklore Studies with Ethnographic Museum - BAS.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker-alt fas\"][acf field=\"acf_bas_address\"][/fusion_li_item][fusion_li_item icon=\"fa-phone-square fas\"][acf field=\"acf_bas_phone\"][/fusion_li_item][fusion_li_item icon=\"fa-fax fas\"][acf field=\"acf_bas_fax\"][/fusion_li_item][fusion_li_item icon=\"fa-at fas\"][acf field=\"acf_bas_email\"][/fusion_li_item][fusion_li_item icon=\"fa-sitemap fas\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Scientific Archive of BAS","post_link":"https://www.bas.bg/?page_id=24589&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Scientific Archive of BAS\" width=\"280\" height=\"180\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/Centralna_biblioteka_BAN.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%_wpmf_gallery_custom_image_link%":"http://archiv.cl.bas.bg/","%_gallery_link_target%":"_blank","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.694809","%_wpgmp_metabox_longitude%":"23.332129","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Scientific Archive of BAS","%acf_bas_fax%":"+359 2 988 40 46","%acf_bas_email%":"<a href=\"mailto:office_sa@cl.bas.bg\">office_sa@cl.bas.bg</a>","%acf_bas_latitude%":"42.694809","%acf_bas_longtitude%":"23.332129","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%_oembed_4e4bbbab22f974dd701064ed6466c298%":"{{unknown}}","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":408,\"to_translate\":{\"en\":408}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16272","%_edit_lock%":"1563200484:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443058","%avada_post_views_count%":"447","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24589,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Specialized Unit","id":"8","type":"category"}]},{"source":"post","title":"Prof. Marin Drinov Publishing House of BAS","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Prof. Marin Drinov Publishing House of BAS\" width=\"200\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/BAN_Izdatelstvo_2-200x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Prof. Marin Drinov Publishing House of BAS</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 6, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 3413</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"https://press.bas.bg/\" target=\"_blank\" rel=\"noopener\">https://press.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24599&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.674897","lng":"23.369516","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24599&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 6, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 3413","%acf_bas_site%":"<a href=\"https://press.bas.bg/\" target=\"_blank\" rel=\"noopener\">https://press.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\" type=\"legacy\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"false\" min_height=\"\" hover_type=\"none\" link=\"\" border_sizes_top=\"\" border_sizes_bottom=\"\" border_sizes_left=\"\" border_sizes_right=\"\" first=\"true\" spacing_right=\"2.6666666666666665%\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"size-medium wp-image-16535 alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/BAN_Izdatelstvo_2-200x300.jpg\" alt=\"\" width=\"200\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>P</strong>[/fusion_dropcap]<strong>rof. Marin Drinov Publishing House of BAS</strong> publishes and disseminates scientific papers, journals, collections of articles, scientific catalogs, bibliographies, dictionaries, encyclopaedias, albums and scientific papers of the autonomous and specialized units of the Academy as well as of individual scholars.</p>\r\n<p style=\"text-align: justify;\">The publishing activity of the Academy began in 1869. Organizers and editors of the editions were the first full members of the Bulgarian Academy of Sciences (then \"Bulgarian Learned Society\"): Marin Drinov and Vasil Drumev. In 2015, 145 years elapsed since the first book of the \"Periodical Journal of the Bulgarian Learned Society\" had come out, in 1870 in Braila.</p>\r\n<p style=\"text-align: justify;\">According to the Statute of the Bulgarian Academy of Sciences which was adopted at the General Assembly of BAS on 27 and 28 February 1947 and entered into force on March 1 of the same year, the Academy created a publishing house with a printing house and bindery. In 1994, on the occasion of the 125th anniversary of the creation of the Bulgarian Learned Society, it was renamed to \"Marin Drinov\" Academic Publishing House, and in 2014 the name was again changed to Professor Marin Drinov Academic Publishing House.</p>\r\n<p style=\"text-align: justify;\">The Publishing House of BAS rithmically publishes and prints the six journals, defined as general academic journals: \"Reports of BAS\", \"Journal of BAS\", \"Bulletin of BAS\", \"Reports of BAS. Humanities and Social Sciences\" and the science popular journals \"Nature\" and \"Technosphere\".</p>\r\n<p style=\"text-align: justify;\">Prof. Marin Drinov Publishing House of BAS provides the publication of scientific, scientific reference and science popular literature and contributes to the popularization and dissemination of scientific knowledge. In 2016, the thematic range of published books included titles such as: \"History of BAS. First part. 1869 - 1947\", \"Dictionary of the Bulgarian Language \"(Volume 15), \"The Proto-Bulgarian Necropolis in Balchik\", \"Bulgarian Dialect Atlas. Summing up volume. IV. Morphology\", \u201cThe Cult to Relics and Miraculous Icons. Traditions and Modernity\", \"Mythology of the Human Body. Anthropological Dictionary\" and others. Thirty-eight scientific collections and monographs with a total circulation of 11,780 copies were published. In 2016, 24 journals of scientific units of BAS were published and printed with a total circulation of 10,828 copies.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"true\" border_sizes_top=\"0\" border_sizes_bottom=\"0\" border_sizes_left=\"0\" border_sizes_right=\"0\" first=\"false\" spacing_left=\"1.3333333333333333%\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\" margin_top_small=\"\" margin_bottom_small=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Prof. Marin Drinov Publishing House of BAS","post_link":"https://www.bas.bg/?page_id=24599&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Prof. Marin Drinov Publishing House of BAS\" width=\"200\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/BAN_Izdatelstvo_2-200x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_af27a3ed1d0f74d58dc8dcca81243b10%":"{{unknown}}","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_70af265f9ae7f0d50fa4f26279920ce6%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.baspress.bg","%_gallery_link_target%":"_blank","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.674897","%_wpgmp_metabox_longitude%":"23.369516","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%acf_bas_deptname%":"Prof. Marin Drinov Publishing House of BAS","%acf_bas_fax%":"+359 2 979 3418","%acf_bas_email%":"<a href=\"mailto:p_stoyanova@aph.bas.bg\">p_stoyanova@aph.bas.bg</a>","%acf_bas_latitude%":"42.674897","%acf_bas_longtitude%":" 23.369516","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_oembed_7a53c5fdf7b3574c06ebc4a7cff8f29e%":"{{unknown}}","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpml_word_count%":"{\"total\":378,\"to_translate\":{\"en\":378}}","%_wpml_location_migration_done%":"1","%_wpml_media_duplicate%":"1","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_media_featured%":"0","%_thumbnail_id%":"16535","%_edit_lock%":"1709479641:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"bg_full":"no","display_header":"yes","header_bg_full":"no","slider_visibility":"small-visibility,medium-visibility,large-visibility","show_first_featured_image":"yes","main_padding":{"top":"","bottom":""},"content_bg_full":"no","bg_repeat":"repeat","container_hundred_percent_animation":"","header_bg_repeat":"repeat","displayed_menu":"default","slider_type":"no","slider":"0","wooslider":"0","page_title_bar":"default","content_bg_repeat":"repeat","pages_sidebar":"","pages_sidebar_2":"","sidebar_sticky":"default"},"%_alp_processed%":"1709479778","%avada_post_views_count%":"1017","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24599,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Specialized Unit","id":"8","type":"category"}]},{"source":"post","title":"Institute of Chemical Engineering","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Chemical Engineering\" width=\"300\" height=\"216\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/Logo_IIH-300x216.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Chemical Engineering</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 103, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 870 4227</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.iche.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.iche.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24164&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.673757","lng":"23.3664485","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24164&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 103, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 870 4227","%acf_bas_site%":"<a href=\"http://www.iche.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.iche.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/Logo_IIH-300x216.jpg\" alt=\"\" width=\"300\" height=\"216\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Chemical Engineering (IChE) </strong>is a permanent scientific unit of BAS for chemical engineering and a principal national centre for chemical and biochemical engineering science.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Research and applied activity</h6>\r\n<p style=\"text-align: justify;\">At IChE, both fundamental and applied research is conducted, in priority scientific areas: new technologies, energy saving, new energy sources, environmental protection.\r\nIt works in the following main research fields:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Hydrodynamics, heat and mass transfer processes in multiphase systems;</li>\r\n \t<li>Development of methods for optimal use and storage of energy;</li>\r\n \t<li>Engineering-chemical problems of catalytic processes;</li>\r\n \t<li>Applied aspects of biochemical processes;</li>\r\n \t<li>Energy efficiency;</li>\r\n \t<li>Ecology and environmental protection.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The aim is the development of new industrial processes, apparatuses and technologies, as well as the creation of methods of engineering and chemical systems for the optimal design, management and renovation of the chemical-technological systems.</p>\r\n<p style=\"text-align: justify;\">More than 20 new processes, apparatuses and systems have been developed and implemented in industry with application in environmental protection and energy saving: contact economisers for the use of heat from the fumes of thermal power plants; technologies and apparatus for extracting toxic pollutants from waste gases; a new concept for heterogeneous catalytic reactors; extraction technologies to remove valuable but toxic substances from waste waters and their further utilization.</p>\r\n<p style=\"text-align: justify;\">The scientific staff of the IChE is recognized at international level for contributions in the development of liquid membrane methods for simultaneous extraction and concentration of valuable and toxic substances from waste and natural waters.</p>\r\n<p style=\"text-align: justify;\">The studies in the field of biotechnology relating to various fermentation and enzymatic processes are practically applicable in the pharmaceutical industry as well as for the biological treatment of waste water and the extraction of valuable components from unconventional raw materials. New methods have been developed for optimal energy use in batch and continuous chemical and biochemical processes as well as for the modelling of multicomponent liquid-vapour equilibrium.</p>\r\n<p style=\"text-align: justify;\">IChE Research Groups participate in projects under the COST, COPERNICUS, TEMPUS, 7th Framework Program of the European Union and Horizon 2020. Specialized international scientific meetings and seminars are also organized periodically involving partners from foreign institutes to discuss joint developments . In cooperation with scientists from other European countries, information networks and educational programs are being developed.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Chemical Engineering","post_link":"https://www.bas.bg/?page_id=24164&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Chemical Engineering\" width=\"300\" height=\"216\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/Logo_IIH-300x216.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_8e53c24ec6cb2e08de4b7ae6daa73fb1%":"{{unknown}}","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%_oembed_a7ecac378ae7c364204bbc1bde7f6059%":"{{unknown}}","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%acf_bas_deptname%":"Institute of Chemical Engineering","%acf_bas_fax%":"+359 2 870 7523","%acf_bas_email%":"<a href=\"mailto:ichemeng@bas.bg\">ichemeng@bas.bg</a>","%acf_bas_latitude%":"42.673757","%acf_bas_longtitude%":"23.3664485","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.673757","%_wpgmp_metabox_longitude%":"23.3664485","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"9\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpmf_gallery_custom_image_link%":"http://www.iche.bas.bg","%_gallery_link_target%":"_blank","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":415,\"to_translate\":{\"en\":415}}","%_wpml_media_featured%":"1","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16502","%_edit_lock%":"1563100675:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443010","%avada_post_views_count%":"777","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24164,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Academic Specialized Unit","id":"9","type":"category"}]},{"source":"post","title":"National Museum of Natural History","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Museum of Natural History\" width=\"271\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/logo_nmnhs_black-271x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">National Museum of Natural History</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 1 Tsar Osvoboditel Blvd.,\u00a01000 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 988 5116</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.nmnhs.com\" target=\"_blank\" rel=\"noopener\">http://www.nmnhs.com</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24418&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.69559590000001","lng":"23.328456500000016","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24418&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"1 Tsar Osvoboditel Blvd.,\u00a01000 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 988 5116","%acf_bas_site%":"<a href=\"http://www.nmnhs.com\" target=\"_blank\" rel=\"noopener\">http://www.nmnhs.com</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/logo_nmnhs_black-271x300.jpg\" alt=\"\" width=\"271\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>N</strong>[/fusion_dropcap]<strong>ational Museum of Natural History (NMNHS-BAS)</strong> has a dual function: on the one hand, it is a scientific institution which employs leading specialists in the field of classical natural science and an expert center in the field of environmental protection, on the other - it is a cultural and educational center of national importance presenting to society the knowledge of nature. It is the oldest museum in Bulgaria and the richest natural history museum in the Balkans.</p><p style=\"text-align: justify;\">NMNHS is the only national institution directly involved in the preservation of scientific collections of living and non-living nature from Bulgaria and the world.</p><h6 style=\"text-align: justify;\">Research and applied activity</h6><p style=\"text-align: justify;\">Major research goals are the study of nature, the evolution of organisms and the conservation of natural biodiversity. It is no accident that the priority directions for NMNHS are fundamental studies in the field of classical natural sciences and nature conservation studies. That is why the developed scientific directions in the museum are:</p><ul style=\"text-align: justify;\"><li>Taxonomy, faunistics, zoogeography and animal ecology;</li><li>Evolution of fossil mammals and birds;</li><li>Paleoanthropology;</li><li>Floristics;</li><li>Mineralogy.</li></ul><p style=\"text-align: justify;\">NMNHS is a national center for biospeleology and research and conservation of bat-fauna as well as a main research unit in the field of entomology, archaeozoology and palaeontology of vertebrates. At NMNHS, students and PhD students in all the mentioned fields are being taught.</p><p style=\"text-align: justify;\">Today NMNHS is the only or major research center in Bulgaria in the field of bio-speleology and study and conservation of the bat fauna, entomology, palaeontology of vertebrates and archaezoology. In the museum as a research center, new research areas for Bulgaria such as palaeoornitology and bone morphology of birds are being developed with the creation of the first ornitho-osteological collection in Bulgaria (one of the most important in Europe) and research of the evolution of the mammal megafauna, the hominids and their palaeohabitat.</p><p style=\"text-align: justify;\">Along with the scientific and expert activities, the Museum is also involved in the maintenance of the exposition and the enrichment and processing of scientific collections amounting to almost 1.5 million units. With that, NMNHS implements its educational and promotional mission. Each year, the museum is visited by about 50000 (in some years up to 115 000) people. Its halls serve for practical classes of students, pupils and children. Along with the scientific, also active museum work is done on the maintenance and development of the exposition and the enrichment of the scientific collections that are representative for the country. Temporary themed exhibitions are organized on various occasions.</p><p style=\"text-align: justify;\">Scientists at NMNHS have discovered and described over 340 new - for the world - species and families of contemporary and fossil invertebrate and vertebrate animals as well as plants from all over the world. Among them are the only fossil rhinoceros bird from Europe - a new family for the fossil fauna of the continent, the world's oldest Griffon Vultures, new fossil predators and giant odd-toed ungulates from the Balkans and Central Asia, the supragenual group of subterranean beetles Lovriciina and many more.</p><p style=\"text-align: justify;\">The first international palaeontological expedition in Bulgaria 1985-1987, Bulgarian-French excavations of the Pliocene site near the village of Dorkovo, Western Rhodopes, was also organized and conducted by NMNHS. Today, the locality is considered to be a reference for the beginning of the Pliocene and the continental fauna and nature of that time in Eastern Europe. Dorkovo is also the richest trove of Anancus arvernensis in the world. In 2013, the exposition of a palaeontological museum near Dorkovo was completed, which presented the natural environment 5 million years ago in the Balkans through dioramas, sculpture reconstructions of ancient animals, imitation of excavations, exposed fossils and visual materials. The concept of the exposition was created by scientists at NMNHS. The museum was officially opened by the President of the Republic of Bulgaria in September 2013.</p><p style=\"text-align: justify;\">Scientists from NMNHS are constantly sought as experts, at national level, in the field of nature conservation. They participate in national projects and committees; provide their qualifications and knowledge to help state authorities, related scientific institutions in Bulgaria and abroad.</p><p style=\"text-align: justify;\">NMNHS is the National Center for the Implementation of the Washington Convention on International Trade in Endangered Species of Wild Fauna and Flora (CITES). The museum is one of the two scientific institutions that developed the latest edition of the Red Book of Bulgaria. Museum scientists are involved in all stages of the construction of the European Natura 2000 European Nature Conservation Network in Bulgaria. It is among the leading national institutions for monitoring biodiversity.</p><p style=\"text-align: justify;\">The scientific expeditions of the museum specialists are a characteristic activity which has a great scientific contribution and a public response. Zoological studies have been carried out in almost all continents and in many regions of the world: the Himalayas, Cuba, Mexico, China, Mongolia, Turkey, Indonesia, a number of African countries, Korea, South America, New Guinea, Europe and others. The collected materials are part of the museum's funds and have made a significant contribution to studying the fauna of dozens of countries around the world. In 1983, the largest expedition of NMNHS was conducted: the complex zoological expedition in Mozambique. It was entirely organized by the museum and was held by a decision of the Presidium of the Bulgarian Academy of Sciences. It brought half a ton of scientific collections of corals, skins and skeletons of large mammals, amphibians and reptiles, preserved in alcohol, and invertebrate fauna. Based on these collections, a new genus and species of semi-coleoptera insect and two new species of large mammals that were new for Mozambique were described. Several expeditions conducted in Asia in 1984-1995 were organized and led by museum collaborators.</p><blockquote><p style=\"text-align: justify;\">NMNHS also operates:</p><p style=\"text-align: justify;\">Bat Research and Conservation Center (BRCC) - deals with the study of the dissemination and biology of all species of bats in Bulgaria, the promotion of their importance, the development of plans and strategies for their protection and management of the significant habitats. At the initiative of scientists from the Bat Research and Conservation Center at the Museum, since 1997, the International Bat Night is celebrated annually. Head: Boyan Petrov.</p><p style=\"text-align: justify;\">Biospeleology Research Center which investigates the subterranean fauna, records of the new species and catalogues the cave-dwelling animals from their capture, transportation to the laboratories and study until the publication of the results. Head: Assoc. Prof. Dr. Petar Beron.</p></blockquote><h6 style=\"text-align: justify;\">Educational activity</h6><p style=\"text-align: justify;\"><strong>Doctoral programs</strong></p><p style=\"text-align: justify;\">There are two PhD programs in the museum (the last accreditation for both programs has maximal grades for the period from 16.11.2015 to 16.11.2021)</p><p style=\"text-align: justify;\">1. Doctoral program in scientific specialty \"Zoology\" (10602)<br />2. Doctoral program in scientific specialty \"Entomology\" (10614)</p><p style=\"text-align: justify;\"><strong>Other educational initiatives</strong></p><p style=\"text-align: justify;\">Since 2012, NMNHS actively conducts educational and promotional activities. Through public-private partnerships, educational programs for children are held throughout the year. Museum scientists run biology internship programs to enable students in biology and environmental conservation to acquire professional field work experience, experience with science collections or in the exposition halls.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-random fas\"]\r\n\r\n<a href=\"http://cetaf.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Consortium of European Taxonomic Facilities (CETAF)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-random fas\"]\r\n\r\n<a href=\"http://www.eurobats.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Agreement on the Conservation of Populations of European Bats (EUROBATS)</a>\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"National Museum of Natural History","post_link":"https://www.bas.bg/?page_id=24418&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Museum of Natural History\" width=\"271\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/logo_nmnhs_black-271x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%_oembed_9a8f552b1f6767d0402a24c7786f221f%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.eurobats.org/","%_gallery_link_target%":"_blank","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.69559590000001","%_wpgmp_metabox_longitude%":"23.328456500000016","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"9\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"National Museum of Natural History","%acf_bas_fax%":"+359 2 988 2894","%acf_bas_email%":"<a href=\"mailto:contact@nmnhs.com\">contact@nmnhs.com</a>","%acf_bas_latitude%":"42.69559590000001","%acf_bas_longtitude%":"23.328456500000016","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":1176,\"to_translate\":{\"en\":1176}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16504","%_edit_lock%":"1562933210:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443036","%avada_post_views_count%":"354","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24418,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Academic Specialized Unit","id":"9","type":"category"}]},{"source":"post","title":"Institute of Optical Materials and Technologies &#8220;Acad. Jordan Malinowski&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Optical Materials and Technologies &#8220;Acad. Jordan Malinowski&#8221;\" width=\"300\" height=\"97\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/IOMT-Logo_bg-300x97.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Optical Materials and Technologies &#8220;Acad. Jordan Malinowski&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 109, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 872 00 73</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.iomt.bas.bg\" target=\"_blank\" rel=\"noopener\"> www.iomt.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24206&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.675515","lng":"23.366879","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24206&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 109, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 872 00 73","%acf_bas_site%":"<a href=\"http://www.iomt.bas.bg\" target=\"_blank\" rel=\"noopener\"> www.iomt.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/IOMT-Logo_bg.jpg\" alt=\"\" width=\"382\" height=\"124\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he mission of the Institute of Optical Materials and Technologies (IOMT) \u201cAcademician Jordan Malinowski\u201d</strong> is to:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Conduct fundamental research on the interaction various types of radiation with condensed matter;</li>\r\n \t<li>Develop high-technology materials, methods and technologies for optical applications in flexible transparent electronics;</li>\r\n \t<li>Create novel materials and registration systems for ecology and biomedicine;</li>\r\n \t<li>Train highly qualified personnel in these areas;</li>\r\n \t<li>Conduct interdisciplinary research and joint projects with experts from other research units;</li>\r\n \t<li>Implement the scientific product through innovation and knowledge transfer to industry.</li>\r\n</ul>\r\n<h6 style=\"text-align: justify;\">Research activity</h6>\r\n<p style=\"text-align: justify;\">The research activity is developed in two main thematic areas: \"High-tech optical materials for application in photonics, sensory and organic optoelectronics\" and \"Process monitoring and visualization of objects with holographic methods for recording and processing of information\".</p>\r\n<p style=\"text-align: justify;\">For the period since the establishment of IOMT, in 2010, until present significant fundamental and applied research results have been achieved reflected in more than 450 publications, over 300 of which with impact factor or impact rank as well as 35 monographs / chapters of books. Over 2000 citations have been noted.</p>\r\n<p style=\"text-align: justify;\">One of the greatest achievements of the team is the successful implementation of the project \"Development of applied research in IOMT through development of high-tech optical materials for modern applications\" worth BGN 4.6 million under OP \"Development of the Competitiveness of the Bulgarian Economy 2007- 2013 \". The modern equipment purchased under the project as well as the new specialized laboratories for its functioning created conditions not only for conducting scientific and applied research at contemporary European level but also for improving the quality of training of PhD students, young scientists and specialists.</p>\r\n<p style=\"text-align: justify;\">As the most prominent scientist who worked at the Institute, Academician Jordan Malinowski (1923-1996) stands out: founder and long-time director of the Central Laboratory of Photoprocesses; President of BAS; winner of a number of prestigious national and international awards; member of the American society for photographic science and technique; honorary member of the Royal Photographic Society of Great Britain; corresponding-member of the German Society for Photography, member of the European Academy of Sciences and Arts; Doctor Honoris Causa of the University of Mons, Belgium.</p>\r\n<p style=\"text-align: justify;\">Scientists from IOMT are members of prestigious international scientific societies: Optical Society of America (OSA), International Society for Optics and Photonics (SPIE), European Physical Society (EPS).</p>\r\n<p style=\"text-align: justify;\">IOMT has developed a technology for the production of linear and circular encoder gratings for position sensors, ready to be implemented in small and medium-sized enterprises.\r\nThree-dimensional holographic images of museum exhibits, archaeological and other objects are created at IOMT in order to preserve and promote the cultural and historical heritage of Bulgaria.</p>\r\n<p style=\"text-align: justify;\">A permanent holographic exhibition, open to external visitors, is exhibited in the building of the Institute. Holographic exhibitions are organized in the country and abroad, thus expanding access to cultural products for more and more citizens.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Doctoral Programs:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>In 2014, IOMT received accreditation from NEAA for doctoral studies in all three specialties for which it had applied, namely:</li>\r\n \t<li>Professional field 4.1. Chemical Sciences, \"Physical Chemistry\"</li>\r\n \t<li>Professional field 4.2. Physical Sciences, \"Electrical, Magnetic and Optical Properties of Condensed Matter\"</li>\r\n \t<li>Professional field 4.2. Physical Sciences, \"Physics of Wave Processes\"</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">Other educational initiatives:</p>\r\n\r\n<ul>\r\n \t<li style=\"text-align: justify;\">IOMT has been participating in the project \"Student practices\", BG051PO001-3.3.07-0002, which is implemented with the financial support of Operational Program \"Human Resources Development\", cofinanced by the European Social Fund of the European Union</li>\r\n \t<li style=\"text-align: justify;\">IOMT conducts teaching and training of pupils from secondary schools (National Vocational High School in Precision Engineering and Optics \"Lomonosov\" and Vocational High school in Mechanical Electrotechnics \"Nikola Vaptsarov\")</li>\r\n</ul>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Optical Materials and Technologies &#8220;Acad. Jordan Malinowski&#8221;","post_link":"https://www.bas.bg/?page_id=24206&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Optical Materials and Technologies &#8220;Acad. Jordan Malinowski&#8221;\" width=\"300\" height=\"97\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/IOMT-Logo_bg-300x97.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.675515","%_wpgmp_metabox_longitude%":"23.366879","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Optical Materials and Technologies \"Acad. Jordan Malinowski\"","%acf_bas_fax%":"+359 2 872 00 73","%acf_bas_email%":"<a href=\"mailto:iomt@iomt.bas.bg\">iomt@iomt.bas.bg</a>","%acf_bas_latitude%":"42.675515","%acf_bas_longtitude%":"23.366879","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpmf_gallery_custom_image_link%":"http://www.iomt.bas.bg","%_gallery_link_target%":"_blank","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":661,\"to_translate\":{\"en\":661}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16494","%_edit_lock%":"1562677961:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443017","%avada_post_views_count%":"428","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24206,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Metal Science, Equipment and Technologies with Hydro- and Aerodynamics Centre &#8220;Acad. A. Balevski&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Metal Science, Equipment and Technologies with Hydro- and Aerodynamics Centre &#8220;Acad. A. Balevski&#8221;\" width=\"262\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/IMet_Logo-262x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Metal Science, Equipment and Technologies with Hydro- and Aerodynamics Centre &#8220;Acad. A. Balevski&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 67 Shipchenski Prohod Blvd., 1574 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 46 26 220</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://ims.bas.bg\" target=\"_blank\" rel=\"noopener\">http://ims.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24220&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.6779816","lng":"23.3687476","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24220&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"67 Shipchenski Prohod Blvd., 1574 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 46 26 220","%acf_bas_site%":"<a href=\"http://ims.bas.bg\" target=\"_blank\" rel=\"noopener\">http://ims.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/IMet_Logo-262x300.jpg\" alt=\"\" width=\"262\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]T[/fusion_dropcap]he mission of the <strong>Institute of Metal Science, Equipment and Technologies with the Center for Hydro- and Aerodynamics \"Acad. A. Balevski\"</strong> is to contribute to the progress of the research and education in the country by conducting fundamental and applied research and training in the field of:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>metal science,</li>\r\n \t<li>heat treatment,</li>\r\n \t<li>casting,</li>\r\n \t<li>crystallization,</li>\r\n \t<li>structure and properties of metals and alloys,</li>\r\n \t<li>composites and nano-materials,</li>\r\n \t<li>plasticity modeling,</li>\r\n \t<li>destruction of materials,</li>\r\n \t<li>functionality and reliability of construction,</li>\r\n \t<li>ship hydrodynamics,</li>\r\n \t<li>aerodynamics,</li>\r\n \t<li>water transport,</li>\r\n \t<li>ocean and coastal engineering,</li>\r\n \t<li>marine and river disasters and crises,</li>\r\n \t<li>national security and</li>\r\n \t<li>defense of the country.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The most significant scientific and technical achievements which are results of the work of the unit are related to the creation of:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>counter-casting technologies and machines;</li>\r\n \t<li>new materials, equipment, devices and technologies for obtaining metal materials with amorphous and microcrystalline structure;</li>\r\n \t<li>high-nitrogen steels;</li>\r\n \t<li>new superplastic metallic materials and articles thereof;</li>\r\n \t<li>new ultra-light highly porous metal materials;</li>\r\n \t<li>advanced technologies for material testing and relaxation of residual stresses in welding processes;</li>\r\n \t<li>environmentally friendly technologies in the foundry, metallurgy and heat treatment;</li>\r\n \t<li>computerized systems and programs for modeling, simulation and control of technological processes; new materials with special properties for the defense industry;</li>\r\n \t<li>determination of the security, technological security and residual resource of highly responsible and high-risk structures, systems and facilities, including in nuclear energy and sites of national importance.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The founders of the Institute are the prominent Bulgarian scientists, the founders of the gas counter-pressure casting method: Academician Angel Balevski and corresponding-member Ivan Dimov.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Doctoral programs:</p>\r\n<p style=\"text-align: justify;\">02.19.07 \u2013 Protection of the population and the national economy in critical situations (technologies and means of security and protection of critical infrastructure in crises)\r\n02.01.02 \u2013 Material science and technology of the machine building materials\r\n02.01.08 \u2013 Methods of control and testing materials, products and apparatuses\r\n02.01.17 \u2013 Technologies, machines and systems for plastic deformation treatment\r\n02.01.18 \u2013 Technologies, machines and systems for foundry production\r\n02.09.01 \u2013 Material science and heat treatment of metals\r\n02.01.19 \u2013 Technology, machines and systems for welding industry\r\n01.02.05 \u2013 Fluid Mechanics\r\n02.03.01 \u2013 Ship Theory\r\n02.15.17 \u2013 River and Sea Construction</p>\r\n<p style=\"text-align: justify;\">Other educational intiatives:</p>\r\n<p style=\"text-align: justify;\">International Welding Specialist (IWS) \u2013 acc. IWS Guideline - Doc. IAB-252-07</p>\r\n<p style=\"text-align: justify;\">International Welding Practitioner (IWP) \u2013 acc. IWS Guideline - Doc. IAB-252-07</p>\r\n<p style=\"text-align: justify;\">International Welding Inspector (IWI) \u2013 acc. IWS Guideline - Doc. IAB-041-06</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]<a href=\"http://www.micmrc.government.bg/\">Interdepartmental Council on Defense Industry and Security of Supply at the Council of Ministers of the Republic of Bulgaria</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"https://ittc.info/\">Advisory Council and Specialist Committees of The International Towing Tank Conference (ITTC)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://www.ecmar.eu/\">European Council for Maritime Applied R&amp;D (ECMAR)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"https://www.waterborne.eu/\">The European research and innovation platform for waterborne industries (WATERBORNE)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://vftf.eu/\">International Association \u201cVessels for the Future\u201d</a>[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://ec.europa.eu/commission/index_en\" target=\"_blank\" rel=\"noopener noreferrer\">European Commission</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://www.eda.europa.eu/\" target=\"_blank\" rel=\"noopener noreferrer\">European Defense Agency</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.imamhomepage.org/\" target=\"_blank\" rel=\"noopener noreferrer\">International Maritime Association of the Mediterranean (IMAM)</a>\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Metal Science, Equipment and Technologies with Hydro- and Aerodynamics Centre &#8220;Acad. A. Balevski&#8221;","post_link":"https://www.bas.bg/?page_id=24220&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Metal Science, Equipment and Technologies with Hydro- and Aerodynamics Centre &#8220;Acad. A. Balevski&#8221;\" width=\"262\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/IMet_Logo-262x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%_oembed_38e6b60bb503bca2098286c265864928%":"{{unknown}}","%_oembed_c1001cd61904579bb4cc8510b3ed2921%":"<blockquote class=\"wp-embedded-content\" data-secret=\"vrp7C2o1Oo\"><a href=\"http://ims.bas.bg/\">Home page</a></blockquote><iframe class=\"wp-embedded-content\" sandbox=\"allow-scripts\" security=\"restricted\" style=\"position: absolute; clip: rect(1px, 1px, 1px, 1px);\" src=\"http://ims.bas.bg/embed/#?secret=vrp7C2o1Oo\" data-secret=\"vrp7C2o1Oo\" width=\"500\" height=\"282\" title=\"&#8220;Home page&#8221; &#8212; IMS\" frameborder=\"0\" marginwidth=\"0\" marginheight=\"0\" scrolling=\"no\"></iframe>","%_oembed_time_c1001cd61904579bb4cc8510b3ed2921%":"1508415479","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.6779816","%_wpgmp_metabox_longitude%":"23.3687476","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Metal Science, Equipment and Technologies with Hydro- and Aerodynamics Centre \"Acad. A. Balevski\"","%acf_bas_fax%":"+359 2 46 26 202","%acf_bas_email%":"<a href=\"mailto:office@ims.bas.bg\">office@ims.bas.bg</a>","%acf_bas_latitude%":"42.6779816","%acf_bas_longtitude%":"23.3687476","%acf_bas_projects%":"4853, 3953, 3946","%_acf_bas_projects%":"field_59d51129d9790","%_wpmf_gallery_custom_image_link%":"https://ec.europa.eu/commission/index_en","%_gallery_link_target%":"_blank","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":580,\"to_translate\":{\"en\":580}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16484","%_edit_lock%":"1562681157:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443017","%avada_post_views_count%":"1378","%avada_today_post_views_count%":"7","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24220,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Catalysis","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Catalysis\" width=\"300\" height=\"243\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/logo_katalyz-300x243.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Catalysis</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 11, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 35 63</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://ic.bas.bg\" target=\"_blank\" rel=\"noopener\">http://ic.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24279&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.676559","lng":"23.366740","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24279&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 11, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 35 63","%acf_bas_site%":"<a href=\"http://ic.bas.bg\" target=\"_blank\" rel=\"noopener\">http://ic.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/logo_katalyz-300x243.jpg\" alt=\"\" width=\"300\" height=\"243\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Catalysis (IC)</strong> is a leading scientific, research, application and innovation center and center for the training of specialized personnel in Bulgaria and Southeastern Europe on fundamental and applied research in the field of heterogeneous and homogenous catalysis, photocatalysis, chemical kinetics, chemical stabilization and the specific research methods applicable to catalysis.</p>\r\n<p style=\"text-align: justify;\">IC creates novel nanosized catalysts with a regulated structure and properties applicable in the chemical industry, environmental protection processes, alternative fuels - hydrogen, utilization of new energy sources, improvement of the quality of life, etc.</p>\r\n<p style=\"text-align: justify;\">The scientific basis for the selection of new catalytic systems, the chemical stabilization of organic materials, the reactivity of organic compounds, methodical an methodological development of EPR and ENDOR spectroscopy are studied with priority at the Institute; the kinetics and the mechanism of heterogeneous, homogeneous and photocatalytic reactions, catalytic transformations at atomic level are investigated by quantum-chemical methods.</p>\r\n<p style=\"text-align: justify;\">Modern physical methods such as: X-ray photoelectron spectroscopy, X-ray diffraction analysis, infrared and ultraviolet spectroscopy, temperature-programmed desorption, reduction and oxidation, differential scanning calorimetry, M\u00f6ssbauer and EPR spectroscopy are being widely applied.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Significant achievements</h6>\r\n<ul style=\"text-align: justify;\">\r\n \t<li>The effect of the type of phase of the ZrO2 carrier (amorphous, monoclinic and tetragonal) on the structure and catalytic properties of Cu / ZrO2 catalysts for the dehydrogenation of bioethanol to ethyl acetate was investigated during the implementation of the project \"Obtaining alternative fuels from renewable hydrogen-containing raw materials: biogas reforming to hydrogen\". Laboratory technology has been developed to produce clean hydrogen fuel by reforming biogas from local renewable raw materials. The highly efficient mixed platinum catalysts deposited on xPrO2-Al2O3 oxides can provide an intensive process of biogas reforming to hydrogen.</li>\r\n \t<li>An energy-efficient and eco-friendly method has been developed for the production of nanoparticulate magnetite and Ni-substituted materials with spinel structure, potentially used as catalysts, gas sensors, magnetic materials and others. The nanomaterials produced by mechanochemical activation have high dispersibility, super paramagnetic properties at room temperature and high photocatalytic activity in the purification of contaminated water from the textile industry.</li>\r\n \t<li>A standard operating procedure has been developed to produce a new non-platinum Ni-containing anode catalyst for alkaline electrolytic cells (contract \"Anodes of alkaline electrolytic cells using base metals\" with GENCELL Ltd, Petah Tikva, Israel). The catalyst participates in the company's \"Generator G5\" commercial product. The invention is protected by the patent: \"Nickel-Based Catalyst For Fuel Cell\" WO2015 / 142619 A1.</li>\r\n \t<li>New highly active and stable catalysts based on nanosized gold on mixed oxides with a hydrotalcite structure have been developed with a potential application for obtaining pure hydrogen by the water-gas shift reaction of carbon monoxide with water vapor. The invention is protected by the patent \"Gold catalysts supported in CuO-ZnO-Al2O3 production method and the use thereof\", WO 2016/059268 A1.</li>\r\n</ul>\r\n<blockquote>\r\n<p style=\"text-align: justify;\">IC is founder, organizer and seat of the Bulgarian Catalysis Club (BCC), established in 1992.</p>\r\n<p style=\"text-align: justify;\">IC is world-wide known as organizer of the traditional International Symposia on Heterogeneous Catalysis. In 2015, the XI Symposium in a row was organized.</p>\r\n<p style=\"text-align: justify;\">IC organizes also workshops of NATO and UNIDO contract teams and is also an active member of the Balkan Environmental Association (B.EN.A).\r\nIC is the seat of the Bulgarian EPR meetings.</p>\r\n</blockquote>\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">IC scientists are actively involved in the preparation of graduates, PhD students and students by holding lectures, seminars. IC has been registered as an employer under the \"Student Practices\" project of the Human Resource Development Operational Program, with 8 scientists from the institute being registered as mentors. Scientists from IC participate in the work of scientific juries by the defense of dissertations for PhD and Doctor of Sciences degrees and in competitions for occupying academic positions.</p>\r\n<p style=\"text-align: justify;\"><strong>Doctoral programs</strong></p>\r\n<p style=\"text-align: justify;\">4.2. Chemical Sciences:</p>\r\n\r\n<ul>\r\n \t<li style=\"text-align: justify;\">Code 01.05.16 Chemical kinetics and catalysis;</li>\r\n \t<li style=\"text-align: justify;\">Chief 01.05.18 Solid state chemistry.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\"><strong>Doctoral courses</strong></p>\r\n\r\n<ol>\r\n \t<li style=\"text-align: justify;\">Fundamentals of chemical kinetics. Kinetics of catalytic reactions. Methods for Determination of Catalytic Activity, Lecturer: Assoc. Prof. Alexander Elias</li>\r\n \t<li style=\"text-align: justify;\">Scientific bases for the selection and synthesis of heterogeneous catalysts, Lecturer: Prof. Tatyana Tabakova</li>\r\n \t<li style=\"text-align: justify;\">Contemporary instrumentation methods for characterization of catalysts, lecturer: Assoc. Prof. Hristo Kolev</li>\r\n \t<li style=\"text-align: justify;\">Catalysis for environmental protection and energetics, Lecturer: Prof. Sonia Damyanova, PhD</li>\r\n \t<li style=\"text-align: justify;\">Quantum-chemical methods in catalysis, Lecturer: Assoc. Prof. Valentin Alexiev</li>\r\n \t<li style=\"text-align: justify;\">Solutions for the replacement of critical raw materials in high-tech materials and catalysts, Lecturer: Assoc. Prof. Zara Cherkezova-Zheleva</li>\r\n</ol>\r\n<p style=\"text-align: justify;\">IC has participated as a partner in the project \"Development of highly qualified specialists on contemporary materials for environmental protection: from design to innovation\" BG051PO001-3.3.06-0050 under the Operational Program \"Human Resources Development\", European Social Fund.</p>\r\n<p style=\"text-align: justify;\"><strong>Other educational initiatives</strong></p>\r\n<p style=\"text-align: justify;\">Applied Quantum Chemistry course based on the \u201cQuantum Espresso\u201d program on \"Practice and Application of Modeling of Hydrogen Storage Systems and Solar Panel Coatings\u201d.</p>\r\n<p style=\"text-align: justify;\">An agreement with SABIC (Saudi Arabia Basic Industries Corporation), Saudi Arabia for staff training has been concluded.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://efcats.org/\" target=\"_blank\" rel=\"noopener noreferrer\">European Federation of Catalysis Societies (EFCATS)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.iacs-catalysis.org/\" target=\"_blank\" rel=\"noopener noreferrer\">International Association of the Catalysis Societies (IACS)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://efepr.uantwerpen.be/efepr/\" target=\"_blank\" rel=\"noopener noreferrer\">European Federation of EPR Groups (EFEPR)</a>\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Catalysis","post_link":"https://www.bas.bg/?page_id=24279&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Catalysis\" width=\"300\" height=\"243\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/logo_katalyz-300x243.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_7ef68ea1d354a1b8c387309644d4fdb3%":"{{unknown}}","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.676559","%_wpgmp_metabox_longitude%":"23.366740","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Catalysis","%acf_bas_fax%":"+359 2 971 29 67","%acf_bas_email%":"<a href=\"mailto:icatalys@ic.bas.bg\">icatalys@ic.bas.bg</a>","%acf_bas_latitude%":"42.676559","%acf_bas_longtitude%":"23.366740","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":881,\"to_translate\":{\"en\":881}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16481","%_edit_lock%":"1562773249:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%_wpmf_gallery_custom_image_link%":"http://efepr.uantwerpen.be/efepr/","%_gallery_link_target%":"_blank","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443025","%avada_post_views_count%":"609","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24279,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Physical Chemistry &#8220;Acad. Rostislaw Kaischew&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Physical Chemistry &#8220;Acad. Rostislaw Kaischew&#8221;\" width=\"300\" height=\"153\" src=\"https://www.bas.bg/wp-content/uploads/2017/11/IPC-logo-e1510841594575-300x153.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Physical Chemistry &#8220;Acad. Rostislaw Kaischew&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 11, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 2581, +359 2 872 7550</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://ipc.bas.bg\" target=\"_blank\" rel=\"noopener\">http://ipc.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24268&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.67662119999999","lng":"23.36684360000004","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24268&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 11, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 2581, +359 2 872 7550","%acf_bas_site%":"<a href=\"http://ipc.bas.bg\" target=\"_blank\" rel=\"noopener\">http://ipc.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/11/IPC-logo-300x153.jpg\" alt=\"\" width=\"300\" height=\"153\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Physical Chemistry \"Acad. Rostislaw Kaischew\" (IPC) </strong>conducts fundamental and applied research in the field of:</p><ul style=\"text-align: justify;\"><li>Phase formation and growth of crystalline and amorphous materials</li><li>Volume and surface properties in colloidal systems</li><li>Synthesis and characterization of high-tech, multifunctional, micro- and nanocomposite materials intended for industry, environmental protection and improvement of the quality of life.</li></ul><h6 style=\"text-align: justify;\">Research and applied activity</h6><p style=\"text-align: justify;\">The world-renowned Bulgarian physicochemical school in the field of crystal formation and growth has been established at IPC which has played an important role in elucidating the fundamental molecular mechanisms of the formation of new phases. On this basis, the Bulgarian school of colloidal chemistry has also developed, wide-known with an original method of measuring surface forces between liquid-phase boundaries.</p><p style=\"text-align: justify;\">Unique methods for obtaining crystalline substances, highly efficient catalysts and new glass ceramic materials and for modifying crystalline surfaces at atomic level have been developed in IPC. Innovative electrochemical technologies have been developed to obtain functional metal and alloy coatings, implemented in Bulgarian and European enterprises. A methodology has been developed for diagnosing lung maturity in newborns, applied in a number of clinics in Bulgaria, Europe and the United States.</p><p style=\"text-align: justify;\">The founder of the unit is Academician Rostislaw Atanasov Kaischew, a scientist who gained popularity and international recognition for the development of fundamental ideas in the theory of crystal growth. Among the first generation of IPC scientists were the future Academicians A. Sheludko, G. Bliznakov, E. Budevski and J. Malinowski. Here. the Academicians I. Gutzov and D. Exerowa, the corresponding members S. Stoilov and D. Kashchiev and the Professors N. Pangarov, S. Rashkov, D. Nenov, Ch. Nanev, I. Markov, S. Stoyanov, A. Milchev, S. Armyanov, D. Stoychev, I. Krastev, I. Avramov and A. Milchev grew up and made contributions to science.</p><p style=\"text-align: justify;\">Since 2005, IPC has been a Center for Competence in the field of nanophenomena and nanostructures in volume and surface phases. Since 2010, IPC has coordinated Distributed infrastructure of centers for synthesis and characterization of new materials and conservation of archaeological and ethnographic artefacts (INFRAMAT) of the National Roadmap for Research Infrastructure, DCM 354 of 29.06.2017.</p><h6 style=\"text-align: justify;\">Educational activity</h6><p style=\"text-align: justify;\">IPC has accreditation for doctoral programs Physicochemistry and Electrochemistry (including chemical sources of electricity), with 30 PhD students being trained in the Institute in the period 2013-2016.</p><p style=\"text-align: justify;\">Three large-scale contracts for support of PhD students, post-doctoral students and young scientists, two under the Human Resources Development OP (2010-2015) and one (current) under the Science and Education for Smart Growth OP (2017- 2018). The main objective of the projects is to increase the qualifications of young scientists by combining theoretical and practical knowledge in the field of physicochemistry and electrochemistry, studying the latest instrumental and computational methods, acquainting with problems related to intellectual property, innovation, technology transfer, marketing and more.</p><p style=\"text-align: justify;\">To support the preparation of young specialists is the activity of the specialized colloquiums of IPC on \u201cPhase and Crystal Growth\u201d and \u201cSurfaces and Colloids\u201d, \u201cElectro-crystallisation, Galvanic Coatings and Corrosion Processes\u201d. Practical exercises for electrochemistry students from the University of Chemical Technology and Metallurgy, Sofia, as well as student practices under MES project with mentoring programs in the field of thermal analysis, obtaining and properties of \"soft\" nanoparticles for the delivery and controlled release of drugs, protection from corrosion and others.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p></p>[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Physical Chemistry &#8220;Acad. Rostislaw Kaischew&#8221;","post_link":"https://www.bas.bg/?page_id=24268&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Physical Chemistry &#8220;Acad. Rostislaw Kaischew&#8221;\" width=\"300\" height=\"153\" src=\"https://www.bas.bg/wp-content/uploads/2017/11/IPC-logo-e1510841594575-300x153.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_0f473c1300ecf8aad2da7a1ca65f89c5%":"{{unknown}}","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_8298da577998da31ac03dcee80958109%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://ipc.bas.bg","%_gallery_link_target%":"_blank","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.67662119999999","%_wpgmp_metabox_longitude%":"23.36684360000004","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Physical Chemistry \"Acad. Rostislaw Kaischew\"","%acf_bas_fax%":"+359 2 971 2688","%acf_bas_email%":"<a href=\"mailto:physchem@ipc.bas.bg\">physchem@ipc.bas.bg</a>","%acf_bas_latitude%":"42.67662119999999","%acf_bas_longtitude%":"23.36684360000004","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":590,\"to_translate\":{\"en\":590}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16848","%_edit_lock%":"1562771931:18","%_edit_last%":"18","%pyre_demo_slider%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_last_translation_edit_mode%":"native-editor","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443021","%avada_post_views_count%":"555","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24268,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute for Population and Human Studies","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for Population and Human Studies\" width=\"300\" height=\"225\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/IPHS_logo_en-300x225.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute for Population and Human Studies</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 6, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 870 53 03</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.iphs.eu/\" target=\"_blank\" rel=\"noopener\">http://www.iphs.eu/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24529&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.6747402","lng":"23.3695285","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24529&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 6, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 870 53 03","%acf_bas_site%":"<a href=\"http://www.iphs.eu/\" target=\"_blank\" rel=\"noopener\">http://www.iphs.eu/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"size-medium wp-image-24532 alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/IPHS_logo_en-300x225.png\" alt=\"\" width=\"300\" height=\"225\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute for Population and Human Studies (IPHS)</strong> is oriented towards carrying out demographic and psychological research aimed at revealing the regularities and determinants for the development and reproduction of the Bulgarian population as well as for the psychological development and realization of the individual.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">The research strategy of the institute is aimed at helping the institutions to solve problems with demographic and personal development in the context of European integration and present global trends.</p>\r\n<p style=\"text-align: justify;\">Priorities in the research activity of IPHS are:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Structural changes in population due to falling birth rates, ageing, internal and external migration, destabilisation of the family institution, morbidity and other demographic challenges;</li>\r\n \t<li>Demographic behaviour changes: Theories, methodological research and empirical analyses in conditions of economic and demographic crisis;</li>\r\n \t<li>Integration processes and national identity in the context of ethnic, religious, etc. diversity, increased population mobility and globalization;</li>\r\n \t<li>Personal potential for development, lifelong learning and adapting and creating practical approaches for improving the quality of life.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The problematic spheres in which the research in the Demography Department develops include studies on the historical demography of Bulgarian lands, historical migration issues, interrelationship between the rural settlement system and the human potential of the Bulgarian village, demographic problems of birth rate in the ethnic group Roma, analyses of the development of the population of Bulgaria in the 20th and 21st centuries, questions on the health status and access to healthcare of the Roma in a cross-cultural aspect. In 2015, the scientists of the department participated in the preparation of changes in the demographic strategy of Bulgaria, and in 2017, a project for preparation of proposals for measures to overcome the demographic crisis was launched.</p>\r\n<p style=\"text-align: justify;\">The scientific fields in which the activity of the Psychology Department develops are problems of behavior and health in adolescents in a cross-cultural aspect, the values \u200b\u200bof Bulgarians in the period of most recent history of the country, the psychological factors in the processes of lifelong learning, organizational-psychological and personality peculiarities of mental health and well-being, happiness, perfectionism, comparative intercultural analyses of attitudes towards ethnicity, the cognitive-psychological aspects of emotional development in childhood, excellence through the humanistic approach, the career development of PhD students.</p>\r\n<p style=\"text-align: justify;\">Significant neuroscience studies such as the study of visual and tactile perceptions for the diagnosis of child learning abnormalities are also realized. The Department develops new accredited PhD programs such as Counseling Psychology, realizes trainings both independently and in partnership, participates in the preparation of specialists through its scientific associates and their teaching activities in higher education institutions and the training of PhD students.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Scientists from the Institute for Population and Human Studies are lecturers in 11 universities in the country and are actively involved in both training of students under Bachelor's and Master's programs, as well as in the training of graduates.</p>\r\n<p style=\"text-align: justify;\">An essential function and priority of the unit is to accept and train PhD students in the fields of psychology, sociology, statistics and demography and historical demography.</p>\r\n<p style=\"text-align: justify;\">The Standing Commission on Social and Legal Sciences, Security and Defense of NEAA has provided program accreditation to the Institute for all doctoral programs with very high grades.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://adpca.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Association for the Development of the Person-Centered Approach</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.ispp.org/\" target=\"_blank\" rel=\"noopener noreferrer\">International society of political psychology</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://www.ehps.net/\" target=\"_blank\" rel=\"noopener noreferrer\">European Health Psychology Society</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\nEastern-European Ageing Societies in Transition\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.gypsyloresociety.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Gypsy Lore Society</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://www.ehps-net.eu/\" target=\"_blank\" rel=\"noopener noreferrer\">European Historical Population Samples Network</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://esrii.org/\" target=\"_blank\" rel=\"noopener noreferrer\">European Society for Research on Internet Interventions</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://sites.google.com/site/sssinteraction/home\" target=\"_blank\" rel=\"noopener noreferrer\">European Society in Symbolic Interaction</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.eaps.nl/\" target=\"_blank\" rel=\"noopener noreferrer\">European Association of Population Studies</a>\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute for Population and Human Studies","post_link":"https://www.bas.bg/?page_id=24529&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for Population and Human Studies\" width=\"300\" height=\"225\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/IPHS_logo_en-300x225.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_a2a9dab224e8da8f24b95c565e6d9534%":"{{unknown}}","%pyre_wooslider%":"","%_wpmf_gallery_custom_image_link%":"http://www.eaps.nl/","%_gallery_link_target%":"_blank","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.6747402","%_wpgmp_metabox_longitude%":"23.3695285","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute for Population and Human Studies","%acf_bas_fax%":"+359 2 870 32 17","%acf_bas_email%":"<a href=\"mailto:office@iphs.eu\">office@iphs.eu</a>","%acf_bas_latitude%":"42.6747402","%acf_bas_longtitude%":"23.3695285","%acf_bas_projects%":"4317, 4312, 4304","%_acf_bas_projects%":"field_59d51129d9790","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":618,\"to_translate\":{\"en\":618}}","%_wpml_media_duplicate%":"0","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"24532","%_edit_lock%":"1563113363:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443051","%avada_post_views_count%":"950","%avada_today_post_views_count%":"4","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24529,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Astronomy with National Astronomical Observatory","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Astronomy with National Astronomical Observatory\" width=\"300\" height=\"216\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/Institut-po-astronomia-logo-300x216.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Astronomy with National Astronomical Observatory</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 72 Tsarigradsko Shosse Blvd., 1784 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 974 19 10</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://astro.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://astro.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24448&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.6539459","lng":"23.387299999999982","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24448&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"72 Tsarigradsko Shosse Blvd., 1784 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 974 19 10","%acf_bas_site%":"<a href=\"http://astro.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://astro.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\" type=\"legacy\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"false\" min_height=\"\" hover_type=\"none\" link=\"\" border_sizes_top=\"\" border_sizes_bottom=\"\" border_sizes_left=\"\" border_sizes_right=\"\" first=\"true\" spacing_right=\"2.6666666666666665%\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"\" rule_size=\"\" rule_color=\"\" hue=\"\" saturation=\"\" lightness=\"\" alpha=\"\" content_alignment_medium=\"\" content_alignment_small=\"\" content_alignment=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" sticky_display=\"normal,sticky\" class=\"\" id=\"\" margin_top=\"\" margin_right=\"\" margin_bottom=\"\" margin_left=\"\" fusion_font_family_text_font=\"\" fusion_font_variant_text_font=\"\" font_size=\"\" line_height=\"\" letter_spacing=\"\" text_transform=\"\" text_color=\"\" animation_type=\"\" animation_direction=\"left\" animation_color=\"\" animation_speed=\"0.3\" animation_delay=\"0\" animation_offset=\"\" logics=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/Institut-po-astronomia-logo-300x216.png\" alt=\"\" width=\"300\" height=\"216\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Astronomy with the National Astronomical Observatory (IA with NAO)</strong> conducts scientific research in the field of astronomy and astrophysics and prepares specialists and PhD students in this field.</p>\r\n<p style=\"text-align: justify;\">The Institute operates two modern observatories for astronomical observations and research: <a href=\"http://nao-rozhen.org/\" target=\"_blank\" rel=\"noopener noreferrer\">The National Astronomical Observatory (NAO) Rozhen</a> and <a href=\"http://www.astro.bas.bg/~aobel\" target=\"_blank\" rel=\"noopener noreferrer\">Astronomical Observatory (AO)</a> in the town of Belogradchik. The main telescope of NAO Rozhen is a two-meter reflector with optical system Ritchey-Chretien-Coude. The other two optical telescopes of NAO Rozhen, the 60-cm Cassegrain telescope and the 50/70-cm Schmidt telescope, are specialized for photometric observations. Since 2005, NAO Rozhen operates a 15-cm Lyot-coronagraph developed and built at the Institute of Astronomy and mounted in the solar dome. The second observation facility of the Institute, AO Belogradchik, is equipped with a 60-cm Cassegrain reflector.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Research activity</h6>\r\n<p style=\"text-align: justify;\">The Institute of Astronomy with the National Astronomical Observatory (IA with NAO) conducts fundamental research in the field of astronomy, astrophysics and celestial mechanics. These studies are related to the theoretical and practical study of objects, processes and phenomena in the universe and their evolution.</p>\r\n<p style=\"text-align: justify;\">Extreme conditions in the universe, such as large densities, temperatures and magnetic and gravitational fields, near absolute vacuum, speeds close to the speed of light, and temperatures close to absolute zero enable us to study processes in an environment that cannot be achieved in laboratory conditions. The study of astrophysical processes contributes to the development of other sciences with practical applications such as atomic and nuclear physics, plasma physics, magnetohydrodynamics and others. The knowledge gained in the field of astronomy and astrophysics contributes to the forecasting and protection of the Earth from catastrophes such as an asteroid or comet strike, solar storms, climate change, etc.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Doctoral programs in \"Astrophysics and Stellar Astronomy\", \"Astronomy and Celestial Mechanics\" and \"Heliophysics\". Every year, internships for students from Sofia University and the University of Shumen, and schools and workshops for pupils from folk observatories are held in NAO Rozhen.</p>\r\n\r\n<h6 style=\"text-align: justify;\">History</h6>\r\n<p style=\"text-align: justify;\">1952 - A Department of Astronomy (DA) at the Physical Institute of BAS was established.\r\n1957 - The first station in Bulgaria for observation of artificial satellites on Earth at DA was established.\r\n1958 - An Independent Section of Astronomy (ISA) was established at BAS.\r\n1967 - The Bulgarian government took a decision to build a National Astronomical Observatory (NAO).\r\n1970 - A contract with VEB Carl Zeiss, Jena, was signed for the delivery of a 2-meter universal reflector in the Richie-Cretin-Coude system.\r\n1976 \u2013 The Astronomical Observatory - Belogradchik became an observational base of ISA, BAS.\r\n1980 - The 2-m telescope of NAO - Rozhen began regular observation.\r\n1981 - The NAO - Rozhen was officially opened.\r\n1995 - The Institute of Astronomy (IA) was established as a successor to the ISA with NAO.</p>\r\n<p style=\"text-align: justify;\"><strong>National Astronomical Observatory - Rozhen</strong></p>\r\n<p style=\"text-align: justify;\">The National Astronomical Observatory of Rozhen was officially opened on March 13, 1981, but regular observation under scientific programs dates back to September 1980. It is Bulgaria's largest one-off investment in scientific infrastructure (over BGN 12 million) and is still the largest astronomical observatory on the Balkans and in this Southeast Europe region.</p>\r\n<p style=\"text-align: justify;\">Rozhen NAO is equipped with four telescopes: a universal 2m Ritchey-Chretien-Coude (RCC) reflector made by Carl Zeiss, Jena; 50/70cm Schmidt-camera; 60cm reflector by Zeiss, Jena and \u201chome-made\u201d 15cm solar coronagraph. Observations of wide class of astronomical and astrophysical problems \u2013 from investigations of solar system bodies till extragalactic objects are performed at NAO Rozhen: asteroids and comets; spectra of different kinds of stars; stellar clusters; nearby and distant galaxies and quasars, etc.</p>[/fusion_text][fusion_tagline_box backgroundcolor=\"\" shadow=\"yes\" shadowopacity=\"0.70\" border=\"1\" bordercolor=\"\" highlightposition=\"top\" content_alignment=\"center\" link=\"\" button=\"\" linktarget=\"_self\" modal=\"\" button_size=\"\" button_type=\"\" buttoncolor=\"default\" title=\"\" description=\"\" margin_top=\"\" margin_bottom=\"25px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\"]<strong>Eminent scientists who worked at the Institute:</strong>\r\n<p style=\"text-align: center;\">Academician Nikola Bonev,\r\nProf. Malina Popova,\r\nProf. Vladimir Shkodrov,\r\nProf. Zlatan Tsvetanov,\r\nProf. Toma Tomov.</p>\r\n[/fusion_tagline_box][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"true\" border_sizes_top=\"0\" border_sizes_bottom=\"0\" border_sizes_left=\"0\" border_sizes_right=\"0\" first=\"false\" spacing_left=\"1.3333333333333333%\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\" margin_top_small=\"\" margin_bottom_small=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"20px\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\" margin_top_small=\"\" margin_bottom_small=\"\"]National Astronomical Observatory[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker-alt fas\"]Rozhen Peak, Rodopi Mountain (1759 m)[/fusion_li_item][fusion_li_item icon=\"fa-at fas\"]\r\n\r\n<a href=\"mailto:markishki@mail.bg\">markishki@mail.bg</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap fas\"]\r\n\r\n<a href=\"http://nao-rozhen.org/\" target=\"_blank\" rel=\"noopener noreferrer\">http://nao-rozhen.org/</a>\r\n\r\n[/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\" margin_top_small=\"\" margin_bottom_small=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://eas.unige.ch\" target=\"_blank\" rel=\"noopener noreferrer\">European Astronomical Society (EAS)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://www.iau.org\" target=\"_blank\" rel=\"noopener noreferrer\">International Astronomical Union (IAU)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"https://www.aanda.org/board-of-directors\" target=\"_blank\" rel=\"noopener noreferrer\">Board of Directors of Astronomy &amp; Astrophysics (A&amp;A)</a>[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Astronomy with National Astronomical Observatory","post_link":"https://www.bas.bg/?page_id=24448&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Astronomy with National Astronomical Observatory\" width=\"300\" height=\"216\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/Institut-po-astronomia-logo-300x216.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%_wpmf_gallery_custom_image_link%":"http://www.astro.bas.bg/~aobel","%_gallery_link_target%":"_blank","%_oembed_c94979336edabcd7f6acedc87b7b2e49%":"{{unknown}}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.6539459","%_wpgmp_metabox_longitude%":"23.387299999999982","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%acf_bas_deptname%":"Institute of Astronomy with National Astronomical Observatory","%acf_bas_fax%":"+359 2 974 19 10","%acf_bas_email%":"<a href=\"mailto:office@astro.bas.bg\">office@astro.bas.bg</a>","%acf_bas_latitude%":"42.6539459","%acf_bas_longtitude%":"23.387299999999982","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpml_word_count%":"{\"total\":714,\"to_translate\":{\"en\":714}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_thumbnail_id%":"16457","%_edit_lock%":"1709638847:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"bg_full":"no","display_header":"yes","header_bg_full":"no","slider_visibility":"small-visibility,medium-visibility,large-visibility","show_first_featured_image":"yes","main_padding":{"top":"","bottom":""},"content_bg_full":"no","bg_repeat":"repeat","container_hundred_percent_animation":"","header_bg_repeat":"repeat","displayed_menu":"default","slider_type":"no","slider":"0","wooslider":"0","page_title_bar":"default","content_bg_repeat":"repeat","pages_sidebar":"","pages_sidebar_2":"","sidebar_sticky":"default"},"%_alp_processed%":"1709638986","%avada_post_views_count%":"859","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24448,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of General and Inorganic Chemistry","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of General and Inorganic Chemistry\" width=\"300\" height=\"266\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/IONH_logo-300x266.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of General and Inorganic Chemistry</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 11, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 872 48 01</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.igic.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.igic.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24230&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.6764813","lng":"23.366676299999995","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24230&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 11, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 872 48 01","%acf_bas_site%":"<a href=\"http://www.igic.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.igic.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/IONH_logo-300x266.jpg\" alt=\"\" width=\"300\" height=\"266\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he mission of the Institute of General and Inorganic Chemistry (IGIC)</strong> is to conduct fundamental and applied research in the field of inorganic material science.</p><p style=\"text-align: justify;\">Research at IGIC is organized in four directions in harmony with contemporary challenges:<br />- materials for eco-energy, optical and biomedical technologies;<br />- materials and processes to protect the environment and combat climate change;<br />- utilization of natural resources and environmental monitoring;<br />- new approaches to instrumental and theoretical analysis of materials.</p><p style=\"text-align: justify;\">The basis of research is the scientific approach of studying the laws of \"composition-structure-property\" in view of designing materials with desirable properties.</p><p style=\"text-align: justify;\">The greatest achievements since 2015 can be grouped as follows:</p><ul style=\"text-align: justify;\"><li>New phenomena in the oxidation-reduction chemistry of metal centers in deposited metal nanoparticles have been discovered to elucidate the mechanism of catalytic reactions;</li><li>New heterogeneous emission control catalysts containing greenhouse gases, volatile organic substances and nitrogen oxides have been developed.</li><li>A new class of electrode materials for sodium-ion batteries has been identified as an alternative to the current lithium-ion batteries.</li><li>New optical systems based on glass and ceramics are proposed to replace monocrystals;</li><li>New computational approaches for quantum-chemical modeling of the properties of metal-containing materials have been improved.</li><li>High-sensitivity and selective chemical methods for the analysis of plant samples and biological materials for essential and toxic elements have been developed.</li><li>The environmental status of contaminated natural waters and soils have been assessed and improved.</li></ul><h6 style=\"text-align: justify;\">Educational activity</h6><p style=\"text-align: justify;\">IGIC is accredited with the highest grades to teach PhD students in five subjects from the Chemical Sciences division: inorganic chemistry, solid chemistry, chemical kinetics and catalysis, analytical chemistry and theoretical chemistry.</p><p style=\"text-align: justify;\">A program for the training of PhD students, young scientists and post-doctoral students under the title: \"Creation of highly qualified specialists in contemporary materials for environmental protection: from design to innovation\" has been developed.</p><p style=\"text-align: justify;\"><br />IGIC participates in the project \"Student Practices\" under OP SESG as a training organization.</p><h6 style=\"text-align: justify;\">Brief historical overview</h6><p style=\"text-align: justify;\">The Institute of General and Inorganic Chemistry was founded in 1960. Founder of the institute was Academician Georgi Bliznakov, an eminent Bulgarian scientist working in the fields of physical and inorganic chemistry with contributions in the field of crystal growth and heterogenous catalysis. The foundations of analytical research were laid by Professor N. Yordanov.</p><p style=\"text-align: justify;\">The science schools created at IGIC and then developed in Bulgaria are related to inorganic materials (hydrogen accumulation materials, monocrystal growth, super strong composite materials); surface chemistry and gas-solid interaction in particular; studies on topical environmental issues (complete catalytic combustion, environmental monitoring, etc.); inorganic salts and the utilization of natural raw materials (Black Sea lye, etc.).</p><p style=\"text-align: justify;\">In 2005, a Center of Excellence for multifunctional materials and new processes with ecological focus, funded by the European Commission, was set up at IGIC.</p><p style=\"text-align: justify;\">Some of the most prominent Bulgarian scientists in the field of chemistry have worked at IGIC, and their deed is now being developed by corr.-mem. Prof. K. Hadjivanov, DSc - Doctor Honoris Causa of the University of Caen, France (2007), member of Academia Europaea (2012) and of its Committee of Chemical Sciences Section (2014).</p><p style=\"text-align: justify;\">Scientists from IGIC are members of the International Union of Pure and Applied Chemistry (IUPAC) as well as national representatives in department Analytical Chemistry, Inorganic Chemistry and Environment.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of General and Inorganic Chemistry","post_link":"https://www.bas.bg/?page_id=24230&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of General and Inorganic Chemistry\" width=\"300\" height=\"266\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/IONH_logo-300x266.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_c37f16cd456f17997d9a9748f9a2cbf4%":"{{unknown}}","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.6764813","%_wpgmp_metabox_longitude%":"23.366676299999995","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of General and Inorganic Chemistry","%acf_bas_fax%":"+359 2 870 50 24","%acf_bas_email%":"<a href=\"mailto:info@svr.igic.bas.bg\">info@svr.igic.bas.bg</a>","%acf_bas_latitude%":"42.6764813","%acf_bas_longtitude%":"23.366676299999995","%acf_bas_projects%":"4434, 4423, 4400","%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":581,\"to_translate\":{\"en\":581}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16562","%_edit_lock%":"1562684154:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443017","%avada_post_views_count%":"885","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24230,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Biophysics and Biomedical Engineering","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Biophysics and Biomedical Engineering\" width=\"300\" height=\"232\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/bmql2019-logo-300x232-300x232.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Biophysics and Biomedical Engineering</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 105, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 870 3607</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://biomed.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://biomed.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24365&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.672632","lng":"23.365153","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24365&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 105, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 870 3607","%acf_bas_site%":"<a href=\"http://biomed.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://biomed.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/bmql2019-logo-300x232.png\" alt=\"\" width=\"300\" height=\"232\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Biophysics and Biomedical Engineering </strong>is a leading research institute in Bulgaria in the field of biophysics, biochemistry, cell biology and physiology. The Institute is at the forefront of the development of biomedical technologies in the fields of electrophysiology, motor mechanics, information technologies and biologically active substances and demonstrates a successful transfer of technologies to other institutes of BAS, universities, clinics and companies.</p>\r\n<p style=\"text-align: justify;\">The Institute of Biophysics and Biomedical Engineering was established in 2010 by the merger of the Institute of Biophysics at the Bulgarian Academy of Sciences and the Central Laboratory of Biomedical Engineering as their universal successor.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Main achievements of the institute</h6>\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Application of computer simulated models to characterize the generation and spread of potentials in human nerve fibers in norm and pathology with results in the field of motor and clinical neurophysiology.</li>\r\n \t<li>Computer modeling of biomechanical and myoelectric activity and modeling the activity of myelinized axons.</li>\r\n \t<li>Identification of new calorimetric markers for classification and diagnosis of oncological diseases.</li>\r\n \t<li>Electroporation and transmission of DNA and drugs into the cell; application of electrochemotherapy for the treatment of skin tumors.</li>\r\n \t<li>The role of the phospholipid and fatty acid composition of the membranes, sphingolipid signaling as well as omega-3 fatty acids in the formation of domains and maintenance of the lateral organization of the membranes in certain cell pathologies has been established. The effect of antitumor lipids on carcinogenesis has been established.</li>\r\n \t<li>Development of new biocompatible polymer coatings by modifying their surface properties and regulating cell behavior and differentiation.</li>\r\n \t<li>The theory of aggregation networks and intuitionistic fuzzy sets, creation of software systems used in clinical practice for data analysis.</li>\r\n \t<li>Development and implementation in cardiology clinics of a number of systems and modules for analysis of signals characterizing human cardiac activity.</li>\r\n \t<li>Development of specialized software for virtual screening of biologically active molecules and evaluation of their toxic effects with the application of computer-aided (in silico) drug design.</li>\r\n \t<li>Clarification of the correlation between the structure and function of thylakoid membranes and the adaptation mechanisms of the photosynthetic apparatus of cyanobacteria, algae and higher plants under abiotic stress.</li>\r\n</ul>\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\"><strong>Doctoral programs</strong></p>\r\n<p style=\"text-align: justify;\">IBPhBME has accreditation for PhD students training under the following programs:</p>\r\n<p style=\"text-align: justify;\">4.3 Biological Sciences \u2013 Biophysics;\r\n4.3 Biological Sciences - Animal and Human Physiology;\r\n4.6 Informatics and Computer Science \u2013 Informatics;\r\n5.2 Electrical engineering, electronics and automation - Automated information processing and control systems (by industry);\r\n5.2 Electrotechnics, electronics and automation - Application of the principles and methods of cybernetics in different fields of science.</p>\r\n<p style=\"text-align: justify;\"><strong>Lecture courses</strong></p>\r\n<p style=\"text-align: justify;\">IBPhBME specialists hold lecture courses at the:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Training Center of BAS</li>\r\n \t<li>Faculty of Mathematics and Informatics of Sofia University \"St. Kliment Ohridski\"</li>\r\n \t<li>Biological Faculty of Sofia University \"St. Kliment Ohridski\"</li>\r\n \t<li>Faculty of Chemistry and Pharmacy, Sofia University \"St. Kliment Ohridski\"</li>\r\n \t<li>University of Chemical Technology and Metallurgy, Sofia</li>\r\n \t<li>Faculty of Technical Sciences, University \"Prof. Dr. Asen Zlatarov\"- Bourgas</li>\r\n \t<li>Technical University \u2013 Sofia</li>\r\n \t<li>Faculty of Mathematics and Informatics, University of Plovdiv \"Paisii Hilendarski\"</li>\r\n</ul>\r\n<p style=\"text-align: justify;\"><strong>Other educational initiatives</strong></p>\r\n\r\n<ul>\r\n \t<li style=\"text-align: justify;\">IBPhBME actively participates in the MES \"Student Practices\" projects and trains many graduates from different Higher Education Institutions.</li>\r\n \t<li style=\"text-align: justify;\">At IBPhBME, every year, studentrs from Sofia University \"St. Kl. Ohridski\", TU-Sofia, UCTM-Sofia prepare their Bachelor and Master theses .</li>\r\n \t<li style=\"text-align: justify;\">IBPhBME teaches PhD students from other countries for certain periods.</li>\r\n</ul>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Biophysics and Biomedical Engineering","post_link":"https://www.bas.bg/?page_id=24365&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Biophysics and Biomedical Engineering\" width=\"300\" height=\"232\" src=\"https://www.bas.bg/wp-content/uploads/2019/07/bmql2019-logo-300x232-300x232.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_de6c852ae5b3aad27ec29c1b6dabc587%":"{{unknown}}","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.672632","%_wpgmp_metabox_longitude%":"23.365153","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Biophysics and Biomedical Engineering ","%acf_bas_fax%":"+359 2 872 3787","%acf_bas_email%":"<a href=\"mailto:ibphbme@bio21.bas.bg\">ibphbme@bio21.bas.bg</a>","%acf_bas_latitude%":"42.672632","%acf_bas_longtitude%":"23.365153","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpmf_gallery_custom_image_link%":"http://biomed.bas.bg/","%_gallery_link_target%":"_blank","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":585,\"to_translate\":{\"en\":585}}","%_wpml_media_duplicate%":"0","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_edit_lock%":"1562855630:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%_thumbnail_id%":"24368","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443029","%avada_post_views_count%":"538","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24365,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Central Library of BAS","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Central Library of BAS\" width=\"300\" height=\"257\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/Central_Library-300x257.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Central Library of BAS</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 1 \"15 Noemvri\" Str., 1000 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 987 8966</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://cl.bas.bg\" target=\"_blank\" rel=\"noopener\">http://cl.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24579&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.694885","lng":"23.332123","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24579&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"1 \"15 Noemvri\" Str., 1000 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 987 8966","%acf_bas_site%":"<a href=\"http://cl.bas.bg\" target=\"_blank\" rel=\"noopener\">http://cl.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"1\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"none\" sep_color=\"\"][acf field=\"acf_bas_deptname\"][/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/Central_Library-300x257.jpg\" alt=\"\" width=\"300\" height=\"257\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Central Library of the Bulgarian Academy of Sciences (CL-BAS)</strong> is the first scientific library in Bulgaria, established at the same time as the Bulgarian Learned Society in October 1869 in Braila, Romania. Nowadays, it is a national center of literary-documentary heritage and information base for fundamental and applied research.</p>\r\n<p style=\"text-align: justify;\">The Central Library is a multi-branch scientific library with responsibility for building and organizing the national library fund and for library and information services with Bulgarian and foreign literature and access to foreign databases. With the introduction of the ALEPH500 automated library information system, CL-BAS has become one of the most successfully functioning libraries in the country, which builds and manages a library network of 48 specialized libraries in 34 scientific units of the Bulgarian Academy of Sciences and provides the library and informational service of BAS as a complex national scientific center.</p>\r\n<p style=\"text-align: justify;\">With its fund of more than 2 000 000 library documents, the Central Library has made a significant contribution to building the national library and information resources of the country. Through the projects in which it participates, it creates a variety of digital resources and thus integrates successfully into the process of developing the digital information and educational environment.</p>\r\n<p style=\"text-align: justify;\">The Central Library of BAS creates and maintains international book exchange with over 780 scientific institutions from 61 countries. International book exchange in Bulgaria has a long history and rich traditions. The first Bulgarian library which sent its own publications abroad and received others for its funds in return was the library at the Bulgarian Learned Society (BLS). Book exchange is one of the forms of scientific and cultural cooperation between individual countries' libraries, thus providing mutual information on the scientific achievements in the country concerned.</p>\r\n[/fusion_text][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nOnline services\r\n\r\n[/fusion_title][fusion_content_boxes layout=\"icon-on-top\" columns=\"3\" title_size=\"\" heading_size=\"2\" title_color=\"\" body_color=\"\" backgroundcolor=\"#f2efef\" icon=\"\" iconflip=\"\" iconrotate=\"\" iconspin=\"no\" iconcolor=\"#333333\" icon_circle=\"yes\" icon_circle_radius=\"round\" circlecolor=\"rgba(255,255,255,0)\" circlebordersize=\"10\" circlebordercolor=\"\" outercirclebordersize=\"0\" outercirclebordercolor=\"\" icon_size=\"48\" icon_hover_type=\"\" hover_accent_color=\"\" image=\"\" image_id=\"\" image_max_width=\"\" link_type=\"button-bar\" button_span=\"\" link_area=\"link-icon\" link_target=\"_blank\" icon_align=\"left\" animation_type=\"\" animation_delay=\"\" animation_offset=\"\" animation_direction=\"left\" animation_speed=\"0.3\" margin_top=\"40px\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_content_box title=\"NALIS Union Catalogue\" backgroundcolor=\"\" icon=\"fa-search fas\" iconflip=\"\" iconrotate=\"\" iconspin=\"no\" iconcolor=\"\" circlecolor=\"\" circlebordersize=\"0\" circlebordercolor=\"\" outercirclebordersize=\"\" outercirclebordercolor=\"\" image=\"\" image_id=\"\" image_max_width=\"35\" link=\"http://primo.nalis.bg/primo_library/libweb/action/search.do?reset=true&amp;dstmp=1504268480903&amp;vid=BAS_VIEW&amp;prefLang=bg_BG&amp;fn=change_lang&amp;fromLogin=true&amp;backFromPreferences=true\" linktext=\"Click here\" link_target=\"_blank\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" /][fusion_content_box title=\"Catalogue of the Central Library\" backgroundcolor=\"\" icon=\"fa-bookmark fas\" iconflip=\"\" iconrotate=\"\" iconspin=\"no\" iconcolor=\"\" circlecolor=\"\" circlebordersize=\"0\" circlebordercolor=\"\" outercirclebordersize=\"\" outercirclebordercolor=\"\" image=\"\" image_id=\"\" image_max_width=\"35\" link=\"http://aleph.cl.bas.bg/F/2CYYAK65AS4UCUEALVXV2TGFN3Q955237EH14NTKICXLCSNKHU-08992?func=option-update-lng&amp;file_name=find-b&amp;F2=pc-latin&amp;P_CON_LNG=ENG&amp;DOC_LNG_00=ALL&amp;x=29&amp;y=11\" linktext=\"Click here\" link_target=\"_blank\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" /][fusion_content_box title=\"NALIS Repository\" backgroundcolor=\"\" icon=\"fa-book fas\" iconflip=\"\" iconrotate=\"\" iconspin=\"\" iconcolor=\"\" circlecolor=\"\" circlebordersize=\"0\" circlebordercolor=\"\" outercirclebordersize=\"\" outercirclebordercolor=\"\" image=\"\" image_id=\"\" image_max_width=\"\" link=\"http://digilib.nalis.bg/xmlui/handle/nls/85?locale-attribute=en\" linktext=\"Click here\" link_target=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" /][/fusion_content_boxes][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"0px\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nJournals\r\n\r\n[/fusion_title][fusion_portfolio layout=\"carousel\" picture_size=\"auto\" text_layout=\"no_text\" grid_box_color=\"\" grid_element_color=\"\" grid_separator_style_type=\"\" grid_separator_color=\"\" columns=\"2\" column_spacing=\"20\" portfolio_masonry_grid_ratio=\"\" portfolio_masonry_width_double=\"\" one_column_text_position=\"below\" equal_heights=\"no\" number_posts=\"-1\" portfolio_title_display=\"all\" portfolio_text_alignment=\"left\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" filters=\"no\" pull_by=\"tag\" cat_slug=\"\" exclude_cats=\"\" tag_slug=\"cl\" exclude_tags=\"\" pagination_type=\"none\" hide_url_params=\"off\" offset=\"0\" orderby=\"date\" order=\"DESC\" content_length=\"excerpt\" excerpt_length=\"10\" strip_html=\"yes\" carousel_layout=\"title_below_image\" scroll_items=\"\" autoplay=\"yes\" show_nav=\"yes\" mouse_scroll=\"yes\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" /][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nExternal online resources\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.sciencedirect.com/\" target=\"_blank\" rel=\"noopener noreferrer\">Science Direct</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n<p class=\"logo\"><a href=\"https://www.scopus.com/\" target=\"_blank\" rel=\"noopener noreferrer\">Scopus</a></p>\r\n[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://apps.webofknowledge.com/UA_GeneralSearch_input.do?product=UA&amp;search_mode=GeneralSearch&amp;SID=X1JadegiSdHOgRrRxdS&amp;preferencesSaved=\" target=\"_blank\" rel=\"noopener noreferrer\">Web of Science</a>[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://www.mendeley.com/\" target=\"_blank\" rel=\"noopener noreferrer\">Mendeley</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://search.ebscohost.com/\" target=\"_blank\" rel=\"noopener noreferrer\">EBSCOhost</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"https://journals.aps.org/\" target=\"_blank\" rel=\"noopener noreferrer\">American Physical Society</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://www.jstor.org/\" target=\"_blank\" rel=\"noopener noreferrer\">JSTOR</a>[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Central Library of BAS","post_link":"https://www.bas.bg/?page_id=24579&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Central Library of BAS\" width=\"300\" height=\"257\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/Central_Library-300x257.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_6bd45028013c9edc0fc3c92d4c6a2938%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.cl.bas.bg","%_gallery_link_target%":"_blank","%_oembed_d556d309b7c14bf45b6982c2bc2e2768%":"{{unknown}}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.694885","%_wpgmp_metabox_longitude%":"23.332123","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Central Library of BAS","%acf_bas_fax%":"+359 2 987 2500","%acf_bas_email%":"<a href=\"mailto:library@cl.bas.bg\">library@cl.bas.bg</a>","%acf_bas_latitude%":"42.694885","%acf_bas_longtitude%":"23.332123","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_oembed_8faaae9b513795e88401dea8c0a58378%":"{{unknown}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":365,\"to_translate\":{\"en\":365}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16439","%_edit_lock%":"1563200406:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443058","%avada_post_views_count%":"1561","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24579,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Specialized Unit","id":"8","type":"category"}]},{"source":"post","title":"Institute of Mineralogy and Crystallography &#8220;Acad. Ivan Kostov&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Mineralogy and Crystallography &#8220;Acad. Ivan Kostov&#8221;\" width=\"300\" height=\"232\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/IMC_logo-e1508406917835-300x232.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Mineralogy and Crystallography &#8220;Acad. Ivan Kostov&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 107, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 7055</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.imc.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.imc.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24213&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","content":"yes","location":{"lat":"42.6729199","lng":"23.365976199999977","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24213&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 107, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 7055","%acf_bas_site%":"<a href=\"http://www.imc.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.imc.bas.bg</a>","post_excerpt":"yes","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n<span style=\"font-weight: 400;\">[acf field=\"acf_bas_deptname\"]</span>\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/IMC_logo-300x232.png\" alt=\"\" width=\"300\" height=\"232\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]T[/fusion_dropcap]he Institute was established on 01.01.1984 under the name Institute of Applied Mineralogy. Since 01.03.1995, it has been transformed into Central Laboratory of Mineralogy and Crystallography (CLMC) which since 2005 has been named after the distinguished Bulgarian mineralogist and crystallographist Academician Ivan Kostov. The experts of the European Science Foundation and the European Federation of All European Academies, who conducted an international audit of the institutes at the Bulgarian Academy of Sciences in 2009, gave the CLMC an AAA assessment of \"Quality and Productivity\", \"Significance: Socio-Economic Impact\" and \"Prospectives\" after which CLMK was renamed <strong>Institute of Mineralogy and Crystallography \"Acad. Ivan Kostov\" (IMC)</strong>, by decision of the Vth General Assembly of BAS from 01.07.2010.</p>\r\n<p style=\"text-align: justify;\">IMC is a leading unit in the field of mineralogy and crystallography with a multidisciplinary scientific team and modern research infrastructure. The presence of specialists in mineralogy, crystallography, mineral raw materials, chemistry and physics makes it possible to conduct competitive research in a wide range of natural sciences and to solve various problems of natural, technogenic and experimentally modelled mineral systems as well as synthesis and crystal- chemical characterization of new promising materials.</p>\r\n<p style=\"text-align: justify;\">The scientists from the institute are members of national and international unions and societies, supporting their activities and contributing to their development. IMC is the main initiator for the establishment of a Bulgarian Crystallographic Society which, through its initiatives, contributes greatly to upgrading the qualification of PhD students and young scientists from Bulgaria and the Balkan region in the field of crystallography.</p>\r\n<p style=\"text-align: justify;\">IMC works with Bulgarian and foreign scientific organizations to implement scientific and applied research projects. IMC is a sought-after partner in solving scientific-applied and technological tasks related to the extraction and efficient use of mineral resources, characterization of new materials and different products of the pharmaceutical and food industry.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">IMC has program accreditation in professional field 4.4. Earth Sciences, Doctoral program: Mineralogy and Crystallography with a grade of 9.79 valid until 14.04.2020.</p>\r\n<p style=\"text-align: justify;\">For the period 2013- July 2017, the total number of PhD students trained in the unit was 13. Nine PhD students successfully defended their theses within the deadline. There were five newly enrolled PhD students in this period.</p>\r\n<p style=\"text-align: justify;\">IMC offers and conducts specialized courses at the Training Center of BAS in Infrared Spectroscopy; X-ray structural analysis; thermal analysis; minerals - indicators of magma and metamorphic processes and epithermal low sulphide deposits of precious metals.</p>\r\n<p style=\"text-align: justify;\">Specialists from IMC are invited lecturers and hold exercises at New Bulgarian University, Sofia University - geochemistry and \"St. I. Rilski\u201d MGU <span lang=\"en-US\">for</span> Bachelor and Master students.</p>\r\n<p style=\"text-align: justify;\">IMC participates in the MES Student Practices Programme which is financed by OP SESG.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.ima-mineralogy.org/index.htm\" target=\"_blank\" rel=\"noopener noreferrer\">International Mineralogical Association</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://eurominunion.org/\" target=\"_blank\" rel=\"noopener noreferrer\">European Mineralogical Union (EMU)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.iucr.ac.uk/\" target=\"_blank\" rel=\"noopener noreferrer\">International Union of Crystallography (IUCr)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.iugs.org/\" target=\"_blank\" rel=\"noopener noreferrer\">International Union of Geological Sciences (IUGS)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.iagod.org/\" target=\"_blank\" rel=\"noopener noreferrer\">International Association on the Genesis of Ore Deposits (IAGOG)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.inza.unina.it/\" target=\"_blank\" rel=\"noopener noreferrer\">International Natural Zeolite Association (INZA)</a>\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Mineralogy and Crystallography &#8220;Acad. Ivan Kostov&#8221;","post_link":"https://www.bas.bg/?page_id=24213&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Mineralogy and Crystallography &#8220;Acad. Ivan Kostov&#8221;\" width=\"300\" height=\"232\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/IMC_logo-e1508406917835-300x232.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_wpmf_gallery_custom_image_link%":"http://www.iagod.org/","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_76b86c6ab1b22a66428d98b06587addc%":"{{unknown}}","%acf_bas_deptname%":"Institute of Mineralogy and Crystallography \"Acad. Ivan Kostov\"","%acf_bas_fax%":"+359 2 979 7056","%acf_bas_email%":"<a href=\"mailto:mincryst@clmc.bas.bg\">mincryst@clmc.bas.bg</a>","%acf_bas_latitude%":"42.6729199","%acf_bas_longtitude%":"23.365976199999977","%acf_bas_projects%":"3414, 3411, 3409","%_acf_bas_projects%":"field_59d51129d9790","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.6729199","%_wpgmp_metabox_longitude%":"23.365976199999977","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":547,\"to_translate\":{\"en\":547}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16745","%_edit_lock%":"1562678749:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443017","%avada_post_views_count%":"1159","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24213,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Forest Research Institute","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Forest Research Institute\" width=\"300\" height=\"200\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/SgradaIG-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Forest Research Institute</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 132 Sveti Kliment Ohridski Blvd., 1756 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 962 0447</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://fri.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://fri.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24406&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.6309028","lng":"23.353554799999984","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24406&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"132 Sveti Kliment Ohridski Blvd., 1756 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 962 0447","%acf_bas_site%":"<a href=\"http://fri.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://fri.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/Logo_FRI-295x300.jpg\" alt=\"\" width=\"295\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Forest Research Institute (FRI)</strong> conducts fundamental and applied research in forest ecosystems and creates a theoretical basis for practical solutions to forest management systems, forest genetic resources, forest protection, erosion and flood protection, as well as support for policy making and legislative decisions on the conservation of forests and nature.</p>\r\n<p style=\"text-align: justify;\">The institute provides training for PhD students, organizes training courses for raising the qualification of specialists in ecology and forestry. The expert activity of its scientists as consultants, reviewers and experts in various task-oriented and expert councils is widely covered. It has advanced scientific infrastructure: laboratories with state-of-the-art scientific equipment, experimental bases, stationary sites, monitoring network, information center and library. The popularization of scientific results is achieved through the publication of 2 scientific journals, the organization and conducting of scientific conferences, symposia and seminars.</p>\r\n<p style=\"text-align: justify;\">The Forest Research Institute was established in 1928 as an \"Experimental Forestry Service\" at the Ministry of Agriculture and State Property and since 1954, it has been incorporated into the structure of the Bulgarian Academy of Sciences. Distinguished researchers with significant achievements in the field of forest biology have worked at Institute: the Academicians Boris Stefanov, Petko. D. Petkov, Mako Dakov; the corresponding members Vasil Stoyanov, Nikola Penev; Professors Asen Biolchev, Boyan Zahariev, Ilia Radkov, Marin Marinov, Simeon Nedyalkov, Ivan Raev and others.</p>\r\n<p style=\"text-align: justify;\">The Forest Research Institute participates in international studies of the European Union \u2013 Framework Programs, \"INCO-Copernicus\", \"Leonardo da Vinci\", EUFORGEN (European Forest Genetic Resources Program), COST (European Cooperation in Science and Technology), EFI (European Forest Institute); IUFRO (International Union of Forestry Research Organizations), FAO (Food and Agricultural Organization), UNEP (the United Nations Environmental Program), SCOPE (Scientific Committee on Problems of the Environment), IUBS (International Union of Biological Sciences) as well as conducts research under bilateral cooperation with European, American and Asian scientific units.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">The Institute is accredited for PhD student training as follows:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Higher education area 6. Agricultural sciences and veterinary medicine, professional field 6.1. Plant breeding in scientific specialty Soil Science.</li>\r\n \t<li>Higher education area 6. Agricultural sciences and veterinary medicine, Professional field 6.5. Forestry, scientific specialties: Forestry, selection and seed production; Forestry (including Dendrology); Forest meliorations, forest protection and special uses in forests; Forest management and taxation.</li>\r\n \t<li>Higher education 4. Natural sciences, mathematics and informatics, professional field 4.3. Biological sciences, scientific specialty Ecology and ecosystems conservation.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">Scientists from the Institute have participated in the creation of the specialized course \"Sustainable Forest Management in Bulgaria\" at the Training Center of BAS.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Forest Research Institute","post_link":"https://www.bas.bg/?page_id=24406&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Forest Research Institute\" width=\"300\" height=\"200\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/SgradaIG-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_a6b15d2e85ab389098d42e44c5b2c779%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://fri.bas.bg/","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.6309028","%_wpgmp_metabox_longitude%":"23.353554799999984","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Forest Research Institute","%acf_bas_fax%":"+359 2 962 0447","%acf_bas_email%":"<a href=\"mailto:forestin@bas.bg\">forestin@bas.bg</a>","%acf_bas_latitude%":"42.6309028","%acf_bas_longtitude%":"23.353554799999984","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_oembed_49a33f13b314adb9a2f09a4393f98680%":"{{unknown}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":460,\"to_translate\":{\"en\":460}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16438","%_edit_lock%":"1562929461:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443036","%avada_post_views_count%":"325","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24406,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Plant Physiology and Genetics","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Plant Physiology and Genetics</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 21, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 2606, +359 2 872 8170</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.bio21.bas.bg/ippg/bg/\" target=\"_blank\" rel=\"noopener\">http://www.bio21.bas.bg/ippg/bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24412&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.672358","lng":"23.36490570000001","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24412&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 21, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 2606, +359 2 872 8170","%acf_bas_site%":"<a href=\"http://www.bio21.bas.bg/ippg/bg/\" target=\"_blank\" rel=\"noopener\">http://www.bio21.bas.bg/ippg/bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/IFRG-Logo_BG.jpg\" alt=\"\" width=\"333\" height=\"260\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he mission of the Institute of Plant Physiology and Genetics (IPPG)</strong> involves conducting fundamental and applied research in the field of plant biology which will have a key role to play in solving global problems such as feeding the population under the conditions of adverse climatic changes.</p>\r\n<p style=\"text-align: justify;\">The Institute of Plant Physiology and Genetics was formed on 1 July 2010 following the merger of the Institute of Plant Physiology \"Acad. M. Popov\" and the Institute of Genetics \"Acad. Doncho Kostov\", by decision of the 36th session of the General Assembly of BAS from 23.03.2010.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Research and applied activity</h6>\r\n<p style=\"text-align: justify;\">The priorities of IPPG are as follows:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Creation of new plant species for the plant-breeding industry, food and pharmaceutical industry, public health and environmental protection;</li>\r\n \t<li>Investigations on the physiological and biochemical mechanisms of regulation of plant metabolism and defense mechanisms in plants, contributing to overcoming unfavorable environmental influences and to improving plant resistance;</li>\r\n \t<li>Studies on the organization and functioning mechanisms of hereditary structures in order to characterize and enrich genetic resources and utilize them for the improvement of economically important plant species</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">IPPG is working in the following areas:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Research field \"Molecular biology and genetics\"</li>\r\n \t<li>Research field \"Experimental algology\"</li>\r\n \t<li>Research field \"Plant ecophysiology\".</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">Results have been achieved in the field of:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Creation of new plant forms with valuable economic and biological characteristics such as resistance to abiotic and biotic stress, improved food and taste qualities and higher productivity;</li>\r\n \t<li>Studying the physiological and biochemical bases of metabolism regulation and protective mechanisms in plants helping to overcome adverse environmental impacts and increase their resistance;</li>\r\n \t<li>Studying the organization and functioning mechanisms of hereditary structures in order to characterize and enrich genetic resources and their use for the improvement of economically important, for the country, plant species.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">Under contractual tasks, facilities for the cultivation of spirulina and chlorella have been built. The successful operation of these facilities is a prospect for the resumption of the industrial production of micro-algae biomass in Bulgaria.</p>\r\n<p style=\"text-align: justify;\">Over the years, Academician Emanuil Karanov, corr.-member. Stefan Daskalov, corr.-member Atanas Mehandzhiev and Prof. Dr. Jivko Danailov - Doctor Honoris Causa of the Russian State Agrarian University - Moscow Timiryazev Agricultural Academy worked at the institute.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Accredited Doctoral Programs:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Biochemistry</li>\r\n \t<li>Genetics</li>\r\n \t<li>Plant physiology.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">Number of PhD Students - 6.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]<a href=\"https://www.fespb.org\" target=\"_blank\" rel=\"noopener noreferrer\">Federation of European Societies of Plant Biology (FESPB)</a>[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Plant Physiology and Genetics","post_link":"https://www.bas.bg/?page_id=24412&lang=en","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_wpmf_gallery_custom_image_link%":"http://www.bio21.bas.bg/ippg/bg/","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%_oembed_3fcbd295e62ba0f2d9a9fae00f21900c%":"{{unknown}}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.672358","%_wpgmp_metabox_longitude%":"23.36490570000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Plant Physiology and Genetics","%acf_bas_fax%":"+359 2 873 9952","%acf_bas_email%":"<a href=\"mailto:ifrg@bio21.bas.bg\">ifrg@bio21.bas.bg</a>","%acf_bas_latitude%":"42.672358","%acf_bas_longtitude%":"23.36490570000001","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":458,\"to_translate\":{\"en\":458}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_edit_lock%":"1562930690:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443036","%avada_post_views_count%":"496","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24412,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Ethnology and Folklore Studies with Ethnographic Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Ethnology and Folklore Studies with Ethnographic Museum\" width=\"300\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/logo_iefem-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Ethnology and Folklore Studies with Ethnographic Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Office 1: 6A Moskovska Str., 1000 Sofia; Office 2: Acad. Georgi Bonchev Str., Bl. 6, 1113 Sofia; National Ethnographic Museum: ploshtad \"Knyaz Aleksandar I\" 1, 1000 Sofia</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 988 42 09; +359 2 805 26 11; +359 2 979 30 11; +359 2 870 42 09</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://iefem.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://iefem.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24489&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.696402","lng":"23.327188","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24489&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Office 1: 6A Moskovska Str., 1000 Sofia; Office 2: Acad. Georgi Bonchev Str., Bl. 6, 1113 Sofia; National Ethnographic Museum: ploshtad \"Knyaz Aleksandar I\" 1, 1000 Sofia","%acf_bas_phone%":"+359 2 988 42 09; +359 2 805 26 11; +359 2 979 30 11; +359 2 870 42 09","%acf_bas_site%":"<a href=\"http://iefem.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://iefem.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/09/logo_iefem-300x300.jpg\" alt=\"\" width=\"300\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Ethnology and Folklore Studies with Ethnographic Museum at BAS (IEFSEM - BAS)</strong> was established in 2010 by a decision of the General Assembly of the Bulgarian Academy of Sciences after merging the Institute of Folklore and the Ethnographic Institute with a Museum. As their universal legal successor IEFEM - BAS inherited their history, which had undergone not one or two transformations. The beginning dates back to 1906 when the People's Ethnographic Museum in Sofia was established as a separate museum from the People\u2019s Museum (established in 1892). The merit of it belongs to the then Minister of National Enlightenment Prof. Ivan Shishmanov, and its first director was Dimitar Marinov. In 1947, the Bulgarian Academy of Sciences established an Institute of People's Studies which, in 1949, merged with the National Ethnographic Museum. The Ethnographic Institute with a Museum was established, with first director Acad. Stoyan Romanski. In 1973, the section of folklore was separated from it, and the Institute of Folklore was established with the director Acad. Petar Dinekov. In 2010, as a result of the reform in the Bulgarian Academy of Sciences, the two institutes were merged again.</p>\r\n<p style=\"text-align: justify;\">Over the years, the most important names in Bulgarian ethnography and folklore have worked in the institutions whose successor is IEFSEM - BAS: Dimitar Marinov (1846-1940), Acad. Anton Popstoilov (1869-1928), Dr. Evdokia Peteva-Filova (1901-1973), Stefan L. Kostov (1879-1939, corresponding member of BAS), Dr. Krustyu Miiatev (1892-1966), Prof. Hristo Vakarelski (1896-1979, the first Bulgarian laureate of Herder Prize \u2013 1965), Prof. Vasil Stoin (1880-1938), Prof. Rayna Katsarova-Kukudova (1901-1984), Academician Stoyan Romanski 1987), Prof. Dr. Christo N. Gandev (1907\u20131987), Prof. Tsvetana Romanska (1914\u20131969), Prof. Maria Veleva (1914-1987), Prof. Rositsa Angelova-Georgieva (1917-1990), Acad. Petar Dinekov (1910-1992), Acad. Veselin Hadjinikolov (1917-2003), Prof. Dr. Georgi Georgiev (1931-1990), Prof. DSc Stoyan Genchev (1936-1990), Prof. DSc Todor Iv. Zhivkov (1938-2001), Academician Nikolay Kaufman (Doctor Honoris Causa of AMDFA in Plovdiv, 2000), Prof. DSc Anna Ilieva, corr.-mem. Prof. Elka Bakalova (winner of the \"St. Paisii Hilendarski\" State Prize for 2012, the Pythagoras Big Prize for overall contribution to the development of science - 2016), Prof. Stefana Stoykova (Laureate of Herder Prize - 1983), Prof. DSc Radost Ivanova (Laureate of Herder Prize 2002), Prof. DSc Mila Santova (holder of the \"Golden Age\" - star honorary sign of the Ministry of Culture of the Republic of Bulgaria, 2014), Prof. DSc Rachko Popov, Assoc. Prof. Katya Mihaylova (winner of the \"Honored for the Polish Culture\" medal of the Ministry of Culture of the Republic of Poland, 1998 and of the \"Officer's Cross of the Order of Merit of the Republic of Poland\", awarded by the President of the Republic of Poland, 2000), Assoc. Prof. Dr. Elena Marushiakova (Professor at St. Andrews University, United Kingdom, New Age Scientist, 2009 Selection) US State Department Educational and Cultural Affairs Office and Council for International Exchange of Scientists, European Research Council Advanced Grant 2016-2016; Harzing's Publish or Perish: 1152 citations, h-index 15, Web of Knowledge: 238 citations, Scopus: 201 citations),</p>\r\n<p style=\"text-align: justify;\">Assoc. Prof. Dr. Veselin Popov (Professor at St. Andrews University, UK; Harzing's Publish or Perish: 1061 citations, h-index 14, Web of Knowledge: 238 citations, Scopus: 201 citations) and others.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">The institute conducts research, educational and applied activities in the fields of ethnology, folkloristics, cultural and social anthropology, ethnomusicology, ethnochoreology, art studies and museology. Priorities are the research of man and human communities in their historical and contemporary cultural environment; field studies and documentation of traditions, the safeguarding and exposition of material cultural assets; the generation of ideas and strategies in the field of safeguarding of the material and intangible cultural heritage.</p>\r\n<p style=\"text-align: justify;\">The subject of study is the traditional and contemporary culture of Bulgarians and other ethnic and religious communities in Bulgaria in their historical continuity and different forms of manifestation; the transformation and integration processes in the Bulgarian society in the context of world globalization; modern migration processes and their influence on identity; the cultural processes among the Bulgarian communities abroad in the past and the present day.</p>\r\n<p style=\"text-align: justify;\">Comparative research is carried out in a Balkan, European and global context. Methodological management is carried out of the local centers for intangible cultural heritage and the activities in this area of \u200b\u200bthe community center (chitalishte) network in the country, as well as the network of ethnographic museums in the country and their scientific groups as well as other existing collections.</p>\r\n<p style=\"text-align: justify;\">The combination of scholars of different fundamental backgrounds: historians, ethnologists, museologists, philologists, folklorists, culturologists, ethno-musicologists, ethnochoreologists, art historians, etc., allows an in-depth study of the culture of various religious, ethnic and social communities and groups living on the territory of Bulgaria (both those who have been inhabiting it for centuries as well as newly emerging): Christians and Muslims, Danovists, Buddhists, Bulgarians, Turks, Roma, Karakachans, Vlachs, Gagauzes, Armenians, Jews, Poles, Russians, Ukrainians, Czechs, Greeks, pilgrims, football fans, railway modellers, LARP players and others.</p>\r\n<p style=\"text-align: justify;\">Significant results are achieved by scientists and PhD students at IEFSEM - BAS in analyzing the cultural processes among the Bulgarian communities abroad. Each year, the historical and geographic area of \u200b\u200bresearch extends to the traditional Bulgarian diaspora in the Mediterranean, Central and Eastern Europe, the USA, the new migrant communities in Norway, United Kingdom, Finland, Germany, Italy, Slovenia and others. Modern migration and its influence on identity is an important problem circle that is observed, documented and researched by IEFSEM - BAS. The different transformational and integration processes in Bulgarian society in the context of world globalization processes and ever-increasing pan-European and cross-border mobility are also in the focus of scientific interest.</p>\r\n<p style=\"text-align: justify;\">The basic methodological requirement in the ethnological and folkloristic study for personally collected material is the basis of another extremely important result of the work of the scholars - the creation of a database of documents (observations, interviews, photo and video documentation, etc.) on the contemporary cultural processes and forms of expression of the different human communities in Bulgaria and of the Bulgarian ones abroad. By entering the scientific archives of the institute for safeguarding, they enrich the cultural memory depositories on one hand and are a valuable basis for further research on the other.</p>\r\n<p style=\"text-align: justify;\">The results of the field studies and the research analyses of the scholars are presented at national and international conferences organized by IEFSEM - BAS or by other Bulgarian or foreign institutions; they are published in specialized scientific periodicals as well as in separate editions. For the last six years (2010-2016), IEFSEM scholars have published 1598 studies and articles in Bulgarian and international editions, 94 monographs and thematic collections. Along with the scientific analyses, the tradition of publishing the very archival materials - folk songs and their texts \u2013 continues, to answer the public interest in such publications which has increased in recent years.</p>\r\n<p style=\"text-align: justify;\">The achievements of the research are also reflected in the exposition activity of the National Ethnographic Museum. Many of the exhibitions are the result of project work; others aim at presenting the cultural assets owned by the museum; the third are dedicated to significant names from the development of Bulgarian ethnology and folklore. The cultural traditions of different Bulgarian communities as well as of nearby and far-away peoples are presented in the exhibition halls. For the last years, the museum has presented 128 own and visiting exhibitions.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Expert activity</h6>\r\n<p style=\"text-align: justify;\">The scientific achievements of IEFSEM - BAS scholars are the basis of the expertise they provide to different national and European institutions in two main areas - inter-ethnic relations and the integration of ethnic communities in Bulgaria, and cultural heritage - both material and intangible. IEFSEM is a major partner of the Ministry of Culture in the implementation of Bulgaria's cultural policy in preserving the intangible cultural heritage. The expert capacity of the scholars is used in the realization of the National Folk Art Festival in Koprivshtitsa, the National System \"Living Human Treasures - Bulgaria\" and others. The documentation of all the Bulgarian applications entered in the UNESCO lists for safeguarding the intangible cultural heritage - Bistritsa Babi, Nestinarstvo, Chiprovtsi Carpet-Making, the Surova Folk Feast in Pernik (Representative List) and the Festival in Koprivshtitsa (List of Best Practices) has been prepared by scholars from IEFSEM - BAS.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Doctoral Programs: IEFSEM - BAS is accredited in the scientific specialties \"Ethnography\", \"Folkloristics\", \"Museology\", \"Art and Fine Arts\" and \"Musicology, Music and Dance\". As of 01.08.2017, 10 regular PhD students are trained at IEFSEM - BAS. From October 1, 2017, two more newly enrolled regular PhD students (additional admission) will begin their studies.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Other educational initiatives</h6>\r\n<ul>\r\n \t<li style=\"text-align: justify;\">Specialized Doctoral Courses at the Training Centre of BAS: IEFSEM - BAS offers 14 courses: \"Ethnology of Socialism and Post-Socialism\", \"Ethnology of the Balkans\", \"Gypsies / Roma (History, Traditions, Modernity)\", \"Calendar of Holidays of the Balkan Peoples\", \"Field research in Anthropology: case study\", \"Ethnicity and Nationalisms in the Modern World\", \"Traditional Folk Institutions and Normativity in the Balkans\", \"Museums and Museology\", \"Balkan and Slavic Folklore\", \"Traditions, Rituals, Holidays\", \"Bulgarian Folklore: Traditional and contemporary aspects\", \"Models of ritual kinship in Bulgarian culture\", \"How to interpret and explores ethnic identity\", \"Anthropology of disasters and catastrophes.\"</li>\r\n \t<li style=\"text-align: justify;\">Teaching at HEI: Scholars from IEFSEM - BAS hold lecture courses at Sofia University \"St. Kliment Ohridski\", University of Plovdiv \"Paisii Hilendarski\", South-West University \"Neofit Rilski\", National Academy of Arts \"Nikolay Pavlovich\", University of Veliko Tarnovo \"St. Cyril and St. Methodius\" and the Academy of Music, Dance and Fine Arts - Plovdiv.</li>\r\n \t<li style=\"text-align: justify;\">Teaching abroad: Scholars from IEFSEM - BAS hold lectures and lecture courses also at universities abroad (Germany, Estonia, Italy, China, Lithuania, Poland, Russia, USA, Slovakia, Slovenia and Czechia).</li>\r\n \t<li style=\"text-align: justify;\">Participation in Erasmus+ program: IEFSEM - BAS has concluded 25 Agreements with universities in Austria, Germany, Greece, Estonia, Spain, Italy, Poland, Slovakia, Slovenia, Turkey, Croatia, Czechia for mobility of PhD students for study and of scholars for lectures.</li>\r\n \t<li style=\"text-align: justify;\">The Pupils\u2019 Institute of BAS - scholars from IEFSEM - BAS participate as reviewers of projects participating in the Pupils\u2019 Scientific Sessions announced by BAS.</li>\r\n \t<li style=\"text-align: justify;\">Student Practices - In the framework of Agreements with different faculties and departments of the Sofia University \"St. Kliment Ohridski\", students are trained in the museum and in the archive units of IEFSEM - BAS as well as under the \"Student Practices\" project of the Ministry of Education and Science, funded by OP SESG.</li>\r\n \t<li style=\"text-align: justify;\">Creative workshops - The National Ethnographic Museum organizes various educational initiatives for children and adults. Every year for Christmas, March 1 and Easter, creative workshops are held for making ritual objects, for training and performing folk dances, songs and fairy tales. The participants acquire knowledge and skills related to the traditions and culture of the different communities living in Bulgaria.</li>\r\n \t<li style=\"text-align: justify;\">Educational Center of the National Ethnographic Museum - in 2016, the beginning of a donation campaign \"Get to know traditions to love your people!\" was launched to create a permanent and modern Educational Center in the National Ethnographic Museum. Attracting many donors and supporters of the idea will allow the Center to be opened in the end of 2017 - early 2018.</li>\r\n</ul>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\nEuropean Museum Network \u201ePhysical appearances, Bodies, and Societies\u201c\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"https://www.siefhome.org/\" target=\"_blank\" rel=\"noopener noreferrer\">International Society for Ethnology and Folklore (SIEF)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://inasea.net/\" target=\"_blank\" rel=\"noopener noreferrer\">International Association for Southeast European Anthropology (InASEA)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://aseees.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Association for Slavic, East European, &amp; Eurasian Studies (ASEEES)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://www.americananthro.org/\" target=\"_blank\" rel=\"noopener noreferrer\">American Anthropological Association</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"https://www.easaonline.org/\" target=\"_blank\" rel=\"noopener noreferrer\">European Association of Social Anthropologists (EASA)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://iuaes.org/\" target=\"_blank\" rel=\"noopener noreferrer\">International Union of Anthropological and Ethnological Sciences (IUAES)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://icom.museum/\" target=\"_blank\" rel=\"noopener noreferrer\">International Council of Museums (ICOM)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://ictmusic.org/\" target=\"_blank\" rel=\"noopener noreferrer\">International Council for Traditional Music (ICTM)</a>[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Ethnology and Folklore Studies with Ethnographic Museum","post_link":"https://www.bas.bg/?page_id=24489&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Ethnology and Folklore Studies with Ethnographic Museum\" width=\"300\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/09/logo_iefem-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_wpmf_gallery_custom_image_link%":"http://iefem.bas.bg/","%_gallery_link_target%":"_blank","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%pyre_wooslider%":"","%acf_bas_deptname%":"Institute of Ethnology and Folklore Studies with Ethnographic Museum","%acf_bas_fax%":"+359 2 805 26 11; +359 2 870 42 09","%acf_bas_email%":"<a href=\"mailto:office@iefem.bas.bg\">office@iefem.bas.bg</a>, <a href=\"mailto:pr@iefem.bas.bg\">pr@iefem.bas.bg</a>","%acf_bas_latitude%":"42.696402","%acf_bas_longtitude%":"23.327188","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.696402","%_wpgmp_metabox_longitude%":"23.327188","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_oembed_2a0ad463aab597b3ea5ee1a1af718d33%":"{{unknown}}","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":2059,\"to_translate\":{\"en\":2059}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16507","%_edit_lock%":"1563108151:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443047","%avada_post_views_count%":"1916","%avada_today_post_views_count%":"5","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","%_fusion_google_fonts%":"","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24489,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Information and Communication Technologies","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Information and Communication Technologies\" width=\"300\" height=\"220\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/IICT1-300x220.gif\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Information and Communication Technologies</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 25\u0410, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 987 6611, +359 2 870 8494</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.iict.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.iict.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24059&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.674176","lng":"23.368143","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24059&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 25\u0410, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 987 6611, +359 2 870 8494","%acf_bas_site%":"<a href=\"http://www.iict.bas.bg\" target=\"_blank\" rel=\"noopener\">http://www.iict.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/08/logo-iict-bg-300x158.gif\" alt=\"\" width=\"300\" height=\"158\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Information and Communication Technologies (IICT - BAS)</strong> was established with the strategic goal: to overcome the fragmentation of research in the field of information and communication technologies at the Bulgarian Academy of Sciences and to transform IICT - BAS into an important national factor for the development of modern trends in the field of information and communication technologies whose research is visible and significant on a European scale.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">The mission of IICT - BAS is to conduct fundamental and applied research in the field of computer science, information and communication technologies (ICT) and in the development of innovative interdisciplinary applications of these technologies.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Research activity</h6>\r\n<p style=\"text-align: justify;\" align=\"justify\">The established scientific themes of the Institute are aimed at achieving radical progress and development of innovative applications in such key areas of ICT as:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>\r\n<p align=\"justify\">Contemporary calculations: the expected innovative results are related to the development of efficient means for analyzing the reliability of large-scale computer models, high-performance algorithms for parallel processing and supercomputer applications, robust methods and algorithms for microstructural analysis of materials and tissues on the basis of 3D high-resolution images; creating customized biomedical applications; reliable and effective pollution control / environmental recovery models, etc.</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">\"Big\" data: The expected innovative results are related to the construction of high-performance infrastructures for processing large volumes, type and variety of data coming from a variety of input devices (3D computer tomography, thermal camera, high-speed camera, etc.) the development of new methods, tools and applications using \"big\" data in such problematic areas as preservation and conservation of cultural heritage, development of new nanomaterials, etc.</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Intelligent interfaces: innovative results are expected from solving tasks with big computational complexity related to real-life objects or the Internet that will allow for the development of advanced tools for processing text repositories, semantic networks, analysis and synthesis of speech; creating new, effective methods and algorithms for multifunctional interfaces based on eye movement tracing, gesture recognition, mimic, body language, etc., as well as new methods and algorithms for processing information from hyperspectral cameras, acoustic grids, inertial sensors and other devices.</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">Optimization and intelligent management: innovative results are expected from problem solving in such areas as intelligent diagnostics and decision-making, distributed control systems, optimization methods and algorithms, hierarchical multi-threading models, and algorithms for complex systems management. New models and analytical methods for cyber security assessment and management as well as tools to support the development of individual components of cybersecurity capabilities are being developed.</p>\r\n</li>\r\n</ul>\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Doctoral programs</p>\r\n\r\n<ul>\r\n \t<li>01.01.09: Computational Mathematics. Professional Area: 4.5. Mathematics</li>\r\n \t<li>01.01.13: Mathematical modeling and application of mathematics. Professional Area: 4.5. Mathematics</li>\r\n \t<li>01.01.12: Informatics. Professional Field: 4.6. Informatics and Computer Science</li>\r\n \t<li>02.07.20: Communication networks and systems. Professional Field: 5.3. Communication and computer equipment</li>\r\n \t<li>02.21.04: Computer systems, complexes and networks. Professional Field: 5.3. Communication and computer equipment</li>\r\n \t<li>2.21.07: Automated information processing and control systems. Professional Field: 5.2. Electrical engineering, electronics and automatics.</li>\r\n \t<li>2.21.10: Application of the principles and methods of cybernetics in various fields of science. Professional Field: 5.2. Electrical engineering, electronics and automatics.</li>\r\n</ul>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Information and Communication Technologies","post_link":"https://www.bas.bg/?page_id=24059&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Information and Communication Technologies\" width=\"300\" height=\"220\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/IICT1-300x220.gif\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_779533e7d4c0e835278c7188f457f225%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.iict.bas.bg","%_gallery_link_target%":"_blank","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.674176","%_wpgmp_metabox_longitude%":"23.368143","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Information and Communication Technologies ","%acf_bas_fax%":"+359 2 870 7273","%acf_bas_email%":"<a href=\"mailto:iict@bas.bg\">iict@bas.bg</a>","%acf_bas_latitude%":"42.674176","%acf_bas_longtitude%":"23.368143","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":598,\"to_translate\":{\"en\":598}}","%_wpml_media_featured%":"1","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16381","%_edit_lock%":"1562508286:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624442998","%avada_post_views_count%":"727","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"22-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24059,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Biology and Immunology of Reproduction &#8220;Acad. Kiril Bratanov&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Biology and Immunology of Reproduction &#8220;Acad. Kiril Bratanov&#8221;\" width=\"300\" height=\"274\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/LOGO__Logo_bg_color_RGB-300x274.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Biology and Immunology of Reproduction &#8220;Acad. Kiril Bratanov&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 73 Tsarigradsko Shosse Blvd., 1111 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 872 0018</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://ibir.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://ibir.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24376&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.6793613","lng":"23.354441899999983","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24376&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"73 Tsarigradsko Shosse Blvd., 1111 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 872 0018","%acf_bas_site%":"<a href=\"http://ibir.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://ibir.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/08/Logo_bg_color_CMYK-300x274.jpg\" alt=\"\" width=\"300\" height=\"274\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]h<strong>e mission of the Institute of Biology and Immunology of Reproduction \"Acad. Kiril Bratanov\" at the Bulgarian Academy of Sciences (IBIR-BAS)</strong> is related to the implementation of fundamental and applied scientific research, as well as training in the biology and immunology of animal and human reproduction.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">The subject of research of IBIR-BAS is unique at national level and is aimed at solving social problems related to reproductive health, optimal use and restoration of natural resources and improvement of the quality of life.</p>\r\n<p style=\"text-align: justify;\">The main research areas are studying the factors and mechanisms involved in gametogenesis, insemination, implantation and pregnancy; clarifying the processes of autoreactivity and autoimmune response in reproduction; tumors of the reproductive system; stem cells; discovering the role of biomolecules and metabolic processes for the storage and cryopreservation of reproductive tissues and cells; developing biotechnological approaches to artificial fertlization, micromanipulations and embryo transfer in animals.</p>\r\n<p style=\"text-align: justify;\">IBIR is the founder of a new direction in the medical and biological sciences - immunology of reproduction. In 1967, for the first time in the world, Acad. Kiril Bratanov and his collaborators organized and conducted the First Symposium of Immunology of Spermatozoa and Fertilization with the participation of 150 scientists from 21 countries from all over the world. During the 1st Symposium, an International Coordination Committee on Immunology of Reproduction (ICCIR) was established, with K. Bratanov (Bulgaria) and the future Nobel Prize Winner in Medicine and Physiology (2010), Prof. Robert G. Edwards - founder of the in vitro reproduction technology. In his lecture before the Nobel Committee, Professor Edwards emphasized the importance of the immunology of reproduction and the contribution of Acad. Kiril Bratanov in organizing the International Coordination Committee on Immunology of Reproduction in Varna.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Doctoral Programs:</p>\r\n\r\n<ul>\r\n \t<li style=\"text-align: justify;\">Scientific specialty 01.06.17 Animal and human physiology, 4.3. Biological Sciences, 4. Natural Sciences, Mathematics and Informatics;</li>\r\n \t<li style=\"text-align: justify;\">Scientific specialty 01.06.23 Immunology, 4.3. Biological Sciences, 4. Natural Sciences, Mathematics and Informatics;</li>\r\n \t<li style=\"text-align: justify;\">Scientific specialty 04.02.01 Breeding of farm animals, biology and biotechnology of reproduction; 6 Agricultural Sciences and Veterinary Medicine; 6.3 Livestock breeding.</li>\r\n</ul>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://iccir1967.com\" target=\"_blank\" rel=\"noopener noreferrer\">International Coordination Committee of Immunology of Reproduction</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://isir.org.in/isir.htm\" target=\"_blank\" rel=\"noopener noreferrer\">International Society for Immunology of Reproduction</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://esri.org.hu/\" target=\"_blank\" rel=\"noopener noreferrer\">European Society for Reproductive Immunology</a>\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Biology and Immunology of Reproduction &#8220;Acad. Kiril Bratanov&#8221;","post_link":"https://www.bas.bg/?page_id=24376&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Biology and Immunology of Reproduction &#8220;Acad. Kiril Bratanov&#8221;\" width=\"300\" height=\"274\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/LOGO__Logo_bg_color_RGB-300x274.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_385512172abf0a21387d2399c300d30b%":"{{unknown}}","%pyre_wooslider%":"","%_oembed_069418e779da45a42c9eae7d218a048a%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://esri.org.hu/","%_gallery_link_target%":"_blank","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.6793613","%_wpgmp_metabox_longitude%":"23.354441899999983","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Biology and Immunology of Reproduction \"Acad. Kiril Bratanov\"","%acf_bas_fax%":"+359 2 872 0022","%acf_bas_email%":"<a href=\"mailto:ibir@abv.bg\">ibir@abv.bg</a>","%acf_bas_latitude%":"42.6793613","%acf_bas_longtitude%":"23.354441899999983","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":470,\"to_translate\":{\"en\":470}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16377","%_edit_lock%":"1562858834:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443029","%avada_post_views_count%":"561","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24376,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"National Laboratory of Computer Virology","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Laboratory of Computer Virology\" width=\"200\" height=\"200\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/Logo_v1.0-e1502633435166.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">National Laboratory of Computer Virology</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 8, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 973 3398</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"https://nlcv.bas.bg\" target=\"_blank\" rel=\"noopener\">https://nlcv.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24064&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.675251","lng":"23.368371","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24064&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 8, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 973 3398","%acf_bas_site%":"<a href=\"https://nlcv.bas.bg\" target=\"_blank\" rel=\"noopener\">https://nlcv.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\" align=\"justify\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/08/Logo_v1.0-300x300.jpg\" alt=\"\" width=\"300\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he National Laboratory of Computer Virology</strong> at the Bulgarian Academy of Sciences is the only scientific unit in Bulgaria specializing in the field of computer virology, working to ensure maximum computer security, communication security and data security.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">The Computer Virology Laboratory (CVL) was established in 1990 by a decision of the Presidium of the Bulgarian Academy of Sciences, defining computer viruses and their varieties as main scientific issues. In 1994, with a decision of the Sixty-sixth Meeting of the General Assembly of the Bulgarian Academy of Sciences from 13.06.1994, the laboratory was renamed to the National Laboratory of Computer Virology (NLCV) and various aspects of the information security were added to the scientific issues.</p>\r\n<p style=\"text-align: justify;\" align=\"justify\">The National Laboratory of Computer Virology at BAS is an academic specialized unit for:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>\r\n<p align=\"justify\">fundamental and applied research;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">consultancy and expert activity;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">application of scientific results;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">training of highly qualified specialists,</p>\r\n</li>\r\n</ul>\r\n<p style=\"text-align: justify;\" align=\"justify\">as well as for other activities under Art. 2 of the Law of BAS, in the field of:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>\r\n<p align=\"justify\">creation and research of mathematical and heuristic methods and tools for analysis and evaluation of computer viruses;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">creation and updating of existing computer virus database / knowledge;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">creating and researching fundamentally new methods of computer security and anti-virus protection;</p>\r\n</li>\r\n \t<li>\r\n<p align=\"justify\">approbation of national and international software and hardware methods and tools for computer security and anti-virus protection.</p>\r\n</li>\r\n</ul>\r\n<p style=\"text-align: justify;\" align=\"justify\">In general, the Lab's activities are related to counseling, training, prophylaxis, data recovery, system recovery, assessment of access systems, protection systems approbation, detection, analysis and evaluation of malware. The implementation of the scientific and applied research results of the Laboratory is mainly conducted in processes of interaction with governmental organizations, industry, educational public and private institutions, and end users.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"National Laboratory of Computer Virology","post_link":"https://www.bas.bg/?page_id=24064&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Laboratory of Computer Virology\" width=\"200\" height=\"200\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/Logo_v1.0-e1502633435166.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_9109d00ba96a717caf93b71ada705361%":"{{unknown}}","%pyre_wooslider%":"","%_wpmf_gallery_custom_image_link%":"https://nlcv.bas.bg","%_gallery_link_target%":"_blank","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.675251","%_wpgmp_metabox_longitude%":"23.368371","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"9\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"National Laboratory of Computer Virology","%acf_bas_fax%":"+359 2 971 3710","%acf_bas_email%":"<a href=\"mailto:office@nlcv.bas.bg\">office@nlcv.bas.bg</a>","%acf_bas_latitude%":"42.675251","%acf_bas_longtitude%":"23.368371","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":334,\"to_translate\":{\"en\":334}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16375","%_edit_lock%":"1562509750:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624442998","%avada_post_views_count%":"408","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"21-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24064,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Academic Specialized Unit","id":"9","type":"category"}]},{"source":"post","title":"Institute of Neurobiology","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Neurobiology\" width=\"300\" height=\"203\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/SnimkaINB-e1512407348785-300x203.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Neurobiology</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 23, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2\u00a0979 21 51</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"https://inb.bas.bg/\" target=\"_blank\" rel=\"noopener\">https://inb.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24347&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.672532","lng":"23.366353","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24347&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 23, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2\u00a0979 21 51","%acf_bas_site%":"<a href=\"https://inb.bas.bg/\" target=\"_blank\" rel=\"noopener\">https://inb.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\" type=\"legacy\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"false\" min_height=\"\" hover_type=\"none\" link=\"\" border_sizes_top=\"\" border_sizes_bottom=\"\" border_sizes_left=\"\" border_sizes_right=\"\" first=\"true\" spacing_right=\"2.6666666666666665%\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/08/LOGO_INB.jpg\" alt=\"\" width=\"152\" height=\"166\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Neurobiology at BAS (INB-BAS)</strong> is an independent scientific unit within the thematic division \"Biomedicine and Quality of Life\" of the Bulgarian Academy of Sciences.</p>\r\n<p style=\"text-align: justify;\">Fundamental and applied research is carried out at INB-BAS through interdisciplinary neurophysiological, psychophysiological and pharmacological approaches to gain new knowledge about the neurobiological mechanisms of organization, adaptation and regulation in the human and animal body and the pharmacological effects on them; create new diagnostic and prognostic methods to improve the quality of life, the intellectual and physical abilities of man.</p>\r\n\r\n<h6 style=\"text-align: justify;\">History of the unit</h6>\r\n<p style=\"text-align: justify;\">1947 - Institute of Experimental Medicine (IEM) was founded at the Bulgarian Academy of Sciences with subject of activities: fundamental research in physiology, pharmacology and biochemistry. IEM's research activity focused on physiological sciences, and it was renamed Institute of Physiology (IPh) in 1960. The physiological mechanisms of control and self-regulation in the body are studied, and the role of natural and synthetic active substances and drugs in the control and organization of life processes are being clarified. Studies are conducted in the field of fundamental neurosciences at central and peripheral levels. Experimental models are being introduced to investigate the organization of the nervous system, cellular energetics and the therapeutic and toxic effects of drugs at different biological levels. New methodologies for physiological and pharmacological research are introduced through scientific-applied research. Psychophysiology, psychopharmacology and psychophysics are also being developed.</p>\r\n<p style=\"text-align: justify;\">In view of the orientation of the subject of most research units on neuroscience, in 2006 IPh was reorganized into Institute of Neurobiology (INB).</p>\r\n\r\n<h6 style=\"text-align: justify;\">Important historical achievements</h6>\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Contribution to the study and production of the substance Nivalin\u00ae (Prof. D. Paskov);</li>\r\n \t<li>Discovery of the dependence of atrio-ventricular conduction time on cardiac rate upon increased parasympathetic activity (discovery \u2116 10 by Prof. V. Pavlov);</li>\r\n \t<li>Contribution to the discovery and development of purine P2 receptor subtypes (Prof. L. Kazakov);</li>\r\n \t<li>Pioneering research in the field of hyperbaric and cosmic physiology (Assoc. Prof. D. Dimov, Prof. G. Ganchev, Prof. V. Kolev, Assoc. Prof. P. Gatev, Assoc. Prof. V. Grigorova).</li>\r\n</ul>\r\n<h6 style=\"text-align: justify;\">Important achievements from recent years</h6>\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Neurophysiological and neurochemical mechanisms, models and methods for diagnosis, prevention and therapy of motor and cognitive deficits in normal and pathological aging (Parkinson\u2019s disease, Alzheimer's disease, etc.).</li>\r\n \t<li>Neurophysiological, neurochemical and molecular mechanisms and experimental models for the diagnosis, prevention and therapy of socially significant somatic, neurological, neurodegenerative and psychiatric disorders, dysleksy and language disorders, depression, aggression, ischemy, aneurisms, epilepsy, sleep disorders).</li>\r\n \t<li>Physiological, pharmacological and cellular systems in the study of malignant tumors and antitumor agents.</li>\r\n</ul>\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\"><strong>Doctoral programs</strong></p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>accreditation in animal and human physiology - by 2022</li>\r\n \t<li>accreditation in pharmacology - by 2021</li>\r\n \t<li>accreditation in psychophysiology - by 2022.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\"><strong>Other educational initiatives</strong></p>\r\n\r\n<ul>\r\n \t<li style=\"text-align: justify;\">training courses for PhD students at the Training Centre of BAS \u2013 http://edu.bas.bg/courses.html#navtoggg</li>\r\n</ul>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"true\" border_sizes_top=\"0\" border_sizes_bottom=\"0\" border_sizes_left=\"0\" border_sizes_right=\"0\" first=\"false\" spacing_left=\"1.3333333333333333%\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\" margin_top_small=\"\" margin_bottom_small=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Neurobiology","post_link":"https://www.bas.bg/?page_id=24347&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Neurobiology\" width=\"300\" height=\"203\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/SnimkaINB-e1512407348785-300x203.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_d3e43fec1a72ac9385aaee093c71affa%":"{{unknown}}","%acf_bas_deptname%":"Institute of Neurobiology","%acf_bas_fax%":"+359 2\u00a0871 91 09","%acf_bas_email%":"<a href=\"mailto:office@bio.bas.bg\">office@bio.bas.bg</a>","%acf_bas_latitude%":"42.672532","%acf_bas_longtitude%":"23.366353","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.672532","%_wpgmp_metabox_longitude%":"23.366353","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_oembed_dd9114c3f444f17895db8e509da84873%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.bio.bas.bg/neurobio/BG/index.htm","%_gallery_link_target%":"_blank","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":519,\"to_translate\":{\"en\":519}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16374","%_edit_lock%":"1619526396:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"bg_full":"no","display_header":"yes","header_bg_full":"no","page_title_bar_text":"no","show_first_featured_image":"yes","main_padding":{"top":"","bottom":""},"content_bg_full":"no","bg_repeat":"repeat","header_bg_repeat":"repeat","displayed_menu":"default","slider_type":"no","slider":"0","wooslider":"0","page_title_bar":"default","content_bg_repeat":"repeat","pages_sidebar":"","pages_sidebar_2":"","sidebar_sticky":"default"},"%_fusion_google_fonts%":"","%_alp_processed%":"1624443029","%avada_post_views_count%":"782","%avada_today_post_views_count%":"5","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24347,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Balkan Studies with Center for Thracology &#8220;Prof. Alexander Fol&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Balkan Studies with Center for Thracology &#8220;Prof. Alexander Fol&#8221;\" width=\"300\" height=\"228\" src=\"https://www.bas.bg/wp-content/uploads/2020/11/IBCT_Logo_Single_ENG-300x228.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Balkan Studies with Center for Thracology &#8220;Prof. Alexander Fol&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 45 Moskovska Str., 1000 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 980 62 97</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://balkanstudies.bg/bg/\" target=\"_blank\" rel=\"noopener\">http://balkanstudies.bg/bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24479&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.696851","lng":"23.3325728","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24479&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"45 Moskovska Str., 1000 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 980 62 97","%acf_bas_site%":"<a href=\"http://balkanstudies.bg/bg/\" target=\"_blank\" rel=\"noopener\">http://balkanstudies.bg/bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\" type=\"legacy\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"false\" min_height=\"\" hover_type=\"none\" link=\"\" border_sizes_top=\"\" border_sizes_bottom=\"\" border_sizes_left=\"\" border_sizes_right=\"\" type=\"2_3\" first=\"true\" spacing_right=\"2.6666666666666665%\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" content_alignment_medium=\"\" content_alignment_small=\"\" content_alignment=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" sticky_display=\"normal,sticky\" class=\"\" id=\"\" font_size=\"\" fusion_font_family_text_font=\"\" fusion_font_variant_text_font=\"\" line_height=\"\" letter_spacing=\"\" text_color=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\"]\r\n<p style=\"text-align: justify;\"><a href=\"https://www.bas.bg/wp-content/uploads/2020/11/IBCT_Logo_Single_ENG.png\"><img class=\"size-medium wp-image-32174 alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2020/11/IBCT_Logo_Single_ENG-300x228.png\" alt=\"\" width=\"300\" height=\"228\" /></a>[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Balkan Studies with Center for Thracology \"Prof. Alexander Fol\"</strong> is a main national research center and coordinator in the field of Balkan Studies in Southeast Europe.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">Innovation and competitiveness characterize scientific projects and broad-based scientific networks at national and international level. Interdisciplinary research, conducted by the Institute, on the history and modern development of Southeastern Europe and their comparative character are of priority importance for both Bulgarian society and the country as well as for Europe, in view of the accelerated EU integration processes affecting the countries in the region. The persistent scientific interest of the researchers concerns issues related to Thracology, Byzantinism, Orientalistics as well as Balkan cultures and European studies are a significant aspect of the work of the Balkanists, in building and consolidating the notions of an enlarged Europe.</p>\r\n<p style=\"text-align: justify;\">Through its research and educational activities, IBSCT aims to contribute to a new understanding of historical facts, to encourage a broader comparative approach and up-to-date methodology in studying the history of the region, taking into account the ethnic and cultural diversity of Southeast Europe.</p>\r\n<p style=\"text-align: justify;\">IBSCT is an active participant in the extension of the integrated European Research Area network. Over the last five decades, the Institute of Balkan Studies has been working closely with the Balkan Studies Institutes in Bucharest, Belgrade, Thessaloniki, Athens, Moscow and others, through the International Association for Southeast Europe Studies (AIESEE). Its partners are Harvard University (USA), Roma-Tre University (Italy), the Chinese Center for the Study of Ancient Civilizations in Beijing (China) and others.</p>\r\n<p style=\"text-align: justify;\">In 2015, IBSCT was the main organizer of the XIth International Congress on Southeast European Studies under the auspices of UNESCO on \"Southeast Europe and European Integration: Political, Socio-Economic and Cultural Aspects\". The high-level scientific forum gathered in Sofia the world academic elite in the field of Balkan studies, with over 250 participants and guests from 26 countries.</p>\r\n<p style=\"text-align: justify;\">The Center for Thracology became part of the Institute after 2010. It is the seat of the International Council for Indo-European and Thracian Studies, established in 1988. The strong participation of the scholars in the two international congresses in thracology in recent years - in Turkey and Romania, led to the nomination of Bulgaria hosting the XIII Congress of Thracology in 2017.</p>\r\n<p style=\"text-align: justify;\">The time of more than half a century that passed (53 years of the Institute of Balkan Studies and 45 years of the Institute of Thracology) proved not only the broad chronological range of the rich issues mastered in the field of Thracology, Byzantinism, Ottomanism, the new and the latest history of the countries of Southeast Europe, the Balkan culture; during these decades, collaborators were able to capitalize time building on the achievements of their predecessors.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Doctoral programs:</p>\r\n<p style=\"text-align: justify;\">2.2. History and Archaeology:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Old History and Thracology;</li>\r\n \t<li>Medieval general history;</li>\r\n \t<li>New and newest general history;</li>\r\n \t<li>Documentation and archival science, palaeography (including historiography and source studies).</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">2.1.Philology.</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Balkan literature and cultures.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">3.1. Sociology, Anthropology and Cultural Studies.</p>\r\n\r\n<ul>\r\n \t<li style=\"text-align: justify;\">Theory and history of culture.</li>\r\n</ul>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"true\" border_sizes_top=\"0\" border_sizes_bottom=\"0\" border_sizes_left=\"0\" border_sizes_right=\"0\" type=\"1_3\" first=\"false\" spacing_left=\"1.3333333333333333%\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\" margin_top_small=\"\" margin_bottom_small=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\" margin_top_small=\"\" margin_bottom_small=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.icomos-bg.org/?l=2\" target=\"_blank\" rel=\"noopener noreferrer\">Bulgarian National Committee of the International Council on Monuments and sites (BNC of ICOMOS)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://www.icomos.org/en/\" target=\"_blank\" rel=\"noopener noreferrer\">International Council on Monuments and Sites (ICOMOS)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://iaoseh.wordpress.com/\" target=\"_blank\" rel=\"noopener noreferrer\">International Association for Ottoman Social and Economic History</a>\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Balkan Studies with Center for Thracology &#8220;Prof. Alexander Fol&#8221;","post_link":"https://www.bas.bg/?page_id=24479&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Balkan Studies with Center for Thracology &#8220;Prof. Alexander Fol&#8221;\" width=\"300\" height=\"228\" src=\"https://www.bas.bg/wp-content/uploads/2020/11/IBCT_Logo_Single_ENG-300x228.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_a71f120d11c4f64e300e503fd773aefd%":"{{unknown}}","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.696851","%_wpgmp_metabox_longitude%":"23.3325728","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Balkan Studies with Center for Thracology \"Prof. Alexander Fol\"","%acf_bas_fax%":"+359 2 980 62 97","%acf_bas_email%":"<a href=\"mailto:ibct@balkanstudies.bg\">ibct@balkanstudies.bg</a>","%acf_bas_latitude%":"42.696851","%acf_bas_longtitude%":"23.3325728","%acf_bas_projects%":"5051, 5042","%_acf_bas_projects%":"field_59d51129d9790","%_wpmf_gallery_custom_image_link%":"https://iaoseh.wordpress.com/","%_gallery_link_target%":"_blank","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":614,\"to_translate\":{\"en\":614}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"32174","%_edit_lock%":"1605617145:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"bg_full":"no","display_header":"yes","header_bg_full":"no","page_title_bar_text":"no","show_first_featured_image":"yes","main_padding":{"top":"","bottom":""},"content_bg_full":"no","bg_repeat":"repeat","header_bg_repeat":"repeat","displayed_menu":"default","slider_type":"no","slider":"0","wooslider":"0","page_title_bar":"default","content_bg_repeat":"repeat","pages_sidebar":"","pages_sidebar_2":"","sidebar_sticky":"default"},"%_fusion_google_fonts%":"","%_yoast_wpseo_content_score%":"30","%_alp_processed%":"1624443043","%avada_post_views_count%":"862","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24479,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Stephan Angeloff Institute of Microbiology","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stephan Angeloff Institute of Microbiology\" width=\"300\" height=\"205\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/bl.26-300x205.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Stephan Angeloff Institute of Microbiology</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: Acad. Georgi Bonchev Str., Bl. 26, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 3157</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.microbio.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.microbio.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24355&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.6734161","lng":"23.365995399999974","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24355&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"Acad. Georgi Bonchev Str., Bl. 26, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 3157","%acf_bas_site%":"<a href=\"http://www.microbio.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.microbio.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/08/Graphic1-300x300.png\" alt=\"\" width=\"300\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he \u201cStephan Angeloff\u201d Institute of Microbiology</strong> is an established national research center in the field of microbiological sciences. Modern fundamental and applied research on the most up-to-date, fast-growing and promising directions of microbiological science are conducted, namely: general, applied and infectious microbiology, virology, immunology, microbial and plant biotechnology, microbial ecology.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Some of the Institute's most significant achievements are:</h6>\r\n<ol style=\"text-align: justify;\">\r\n \t<li>The new genus Nematodospora and two new, insect-isolated yeasts: Nematodospora algi and Candida cetonia have been identified and described.</li>\r\n \t<li>Catalytic additive for hydrocarbon liquid fuels which provides high combustion efficiency when added to liquid fuels, engines and other combustion plants has been developed.</li>\r\n \t<li>The cell-wall-localized enzymes fructans beta-fructosidases of lactobacilli with inulinic activity have been isolated and purified. Synchronous expression of genes encoding amylase and inulinase has been proved.</li>\r\n \t<li>Laboratory method has been developed for obtaining hydrogen from wheat straw in anaerobic conditions with a selected microbial community and biomethane that makes it applicable for the biodegradation of organic waste and the industrial production of biofuels from renewable carbon sources.</li>\r\n</ol>\r\n<h6 style=\"text-align: justify;\">History of the unit</h6>\r\n<p style=\"text-align: justify;\">IMicB was founded on March 7, 1947 by the distinguished Bulgarian scientist Academician Stephan Angeloff, initially with five units: bacteriological (for medical, agricultural and industrial microbiology), protozoological, virological, immunological and biochemical.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Prominent scientists who have worked or are working at the unit:</h6>\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Prof. Stephan Angeloff, Full Member of BAS \u2013 Honorary Member of the Hungarian Veterinary Association (1930), Doctor honoris causa of Berlin University (1932) and of the Hannover Veterinary Faculty (1940), Honorary member of the Sacri Romani Imperii Academia Caesareo-Leopoldina Naturae Curiosorum in Halle (1940), Corresponding-member of the Academy of Agricultural Sciences (Berlin) (1955), Rector of Sofia University \"St. Kliment Ohridski \"(1941-42), Corresponding-member of BAS (1943), Full member of BAS (1947), \"Laureate of the Dimitrov Prize\" twice \u2013 1950, 1952.</li>\r\n \t<li>Prof. Angel Galabov, Full Member of BAS \u2013 Founder of Europe's First Symposium Network on Antiviral Substances (1974-1990). Founder and First President of the Balkan Society for Microbiology (1998). Member of the Executive Office of the International Institut Pasteur Network and Coordinator for Europe (2007-2011). Honorary member of the Romanian Academy of Medical Sciences (2003). Corresponding member of the Bulgarian Academy of Sciences (2004), Full Member of the Bulgarian Academy of Sciences (2008). Recorded in the Golden Book of Inventors as the author of 35 inventions (2003). Director of IMicB for 17 years (1995-2011). Awarded twice the Honorary sign Marin Drinov on ribbon (2009, 2014).</li>\r\n \t<li>Prof. Ignat Emanuilov, Full Member of BAS \u2013 his main contributions are in the study of bacterial proteinases and their introduction in cheese making as substitutes of chymosin and pepsin for which he was awarded the Dimitrov Prize \u2013 1951;</li>\r\n \t<li>Prof. Kaltcho Markov, Corresponding Member of BAS \u2013 work in the field of physiology and biochemistry of microorganisms, bacterial genetics and general microbiology. Honorary Scientist \u2013 1985;</li>\r\n \t<li>Prof. Iliya Pashev, Full Member of BAS \u2013 Original contributions in the study of a number of infectious animal diseases and the creation of laboratory diagnostic methods. Laureate of the Dimitrov Prize \u2013 1969;</li>\r\n \t<li>Prof. Alexander Toshkov, Corresponding Member of BAS \u2013 Development of methods to combat and diagnose a number of infectious diseases in bees. Honorary Scientist \u2013 1986.</li>\r\n</ul>\r\n<h6 style=\"text-align: justify;\">Doctoral programs</h6>\r\n<p style=\"text-align: justify;\">The Institute has accreditation in the fields of \u201cBiotechnology\u201d, \u201cMicrobiology\u201d, \u201cVirology\u201d, \u201cImmunology\u201d from professional field 4.3.: Biological sciences, field of higher education 4. Natural sciences, mathematics and informatics.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Other educational initiatives</h6>\r\n<p style=\"text-align: justify;\">The Pasteur Laboratory Center is effectively used both for the training of PhD students from various research departments of the Institute as well as for the training of students of molecular biology from the Faculty of Biology at Sofia University, students from the Faculty of Veterinary Medicine of the University of Forestry and New Bulgarian university.</p>\r\n<p style=\"text-align: justify;\">Scientists from IMicB are involved in the training of Bachelor students by direct tutorship and their participation in the research work of different groups, as well as in the training of Master students (graduates). In addition to delivering lectures and seminars at a number of universities in the country, they also provide facilities and conditions for the work over the respective Master's theses. With their active participation in allowing Master students to use the material base and competence of the scientists from IMicB and to prepare their diploma theses there, as well as in appointing young specialists prepared mainly at BF of Sofia University \"St. Kliment Ohridski \", the institute also assists in the program accreditation of universities.</p>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker-alt fas\"][acf field=\"acf_bas_address\"][/fusion_li_item][fusion_li_item icon=\"fa-phone-square fas\"][acf field=\"acf_bas_phone\"][/fusion_li_item][fusion_li_item icon=\"fa-fax fas\"][acf field=\"acf_bas_fax\"][/fusion_li_item][fusion_li_item icon=\"fa-at fas\"][acf field=\"acf_bas_email\"][/fusion_li_item][fusion_li_item icon=\"fa-sitemap fas\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nInternational relations\r\n\r\n[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://www.pasteur.fr/en/institut-pasteur/institut-pasteur-throughout-world/institut-pasteur-international-network\" target=\"_blank\" rel=\"noopener noreferrer\">Institut Pasteur International Network (RIIP) [le R\u00e9seau International des Instituts Pasteur]</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"https://consortiapedia.fastercures.org/consortia/abirisk/\" target=\"_blank\" rel=\"noopener noreferrer\">Anti-Biopharmaceutical Immunization: prediction and analysis of clinical relevance to minimize the RISK (ABIRISK)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.efsa.europa.eu/\" target=\"_blank\" rel=\"noopener noreferrer\">European Food Safety Authority (EFSA)</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.medvetnet.org/\" target=\"_blank\" rel=\"noopener noreferrer\">The Med-Vet-Net Association for Zoonoses Research (MedVetNet)</a>\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Stephan Angeloff Institute of Microbiology","post_link":"https://www.bas.bg/?page_id=24355&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stephan Angeloff Institute of Microbiology\" width=\"300\" height=\"205\" src=\"https://www.bas.bg/wp-content/uploads/2017/08/bl.26-300x205.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%_oembed_ec2e54dbede82f3492b762fcab219b26%":"{{unknown}}","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_0551fa9527ce97c864657ad68fea694e%":"{{unknown}}","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.6734161","%_wpgmp_metabox_longitude%":"23.365995399999974","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Stephan Angeloff Institute of Microbiology","%acf_bas_fax%":"+359 2 870 0109","%acf_bas_email%":"<a href=\"mailto:micb@microbio.bas.bg\">micb@microbio.bas.bg</a>","%acf_bas_latitude%":"42.6734161","%acf_bas_longtitude%":"23.365995399999974","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_oembed_ac58c6c9a862f84c66bfc4460b9ea288%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"https://www.pasteur.fr/en/institut-pasteur/institut-pasteur-throughout-world/institut-pasteur-international-network","%_gallery_link_target%":"_blank","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":779,\"to_translate\":{\"en\":779}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16346","%_edit_lock%":"1562853319:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443029","%avada_post_views_count%":"618","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24355,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Philosophy and Sociology","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Philosophy and Sociology\" width=\"293\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2020/02/ifs_logo_en-293x300.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Philosophy and Sociology</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 13A Moskovska Str., 1000 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 981 7946</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://ips-bas.org/\" target=\"_blank\" rel=\"noopener\">http://ips-bas.org/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24539&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.696970","lng":"23.327790","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24539&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"13A Moskovska Str., 1000 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 981 7946","%acf_bas_site%":"<a href=\"http://ips-bas.org/\" target=\"_blank\" rel=\"noopener\">http://ips-bas.org/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><a href=\"https://www.bas.bg/wp-content/uploads/2020/02/ifs_logo_en.png\"><img class=\"size-medium wp-image-28950 alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2020/02/ifs_logo_en-293x300.png\" alt=\"\" width=\"293\" height=\"300\" /></a>[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute of Philosophy and Sociology at BAS (IPS-BAS)</strong> was established in July 2010 by a decision of the General Assembly of the Academy as the successor of the Institute for Philosophical Research, the Institute of Sociology and the Center for Science Studies and History of Science.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">The Institute of Philosophy and Sociology at BAS conducts complex theoretical and empirical, fundamental and applied, philosophical, sociological, and science-studies-related research on knowledge, values, Man and society, in accordance with the academic, national, and European criteria and world trends in the development of science, and trains highly qualified specialists in the academic disciplines of philosophy, sociology, science studies, and their sub-divisions.</p>\r\n<p style=\"text-align: justify;\">This is a unique institution, the priorities of which are research and analysis and interpretation of research, combined with post-graduate training (provided by the Institute alone or jointly with similar university departments), popularizing of ideas and results, continuance and further development of the analysis of classical and topical fields of social knowledge, such as epistemology and history of philosophy, philosophy and sociology of social structures and many other fields of major significance for the sustainable development of Bulgarian society, for social progress and for the enhanced prosperity of society.</p>\r\n<p style=\"text-align: justify;\">The activities of IPS include provision of expert and consultancy services for the needs of governance and organization in all spheres of social practice related to the needs of the social-economic, cultural, and political development of Bulgaria and the advance of science as a social phenomenon. The mission of the Institute, as part of the Bulgarian Academy of Sciences, is to ensure an adequate knowledge of the social processes and to contribute to the optimization of policy making in major social-economic fields.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Doctoral programs:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>9.4.1. Philosophy of technology</li>\r\n \t<li>9.4.2. The human body in humanities</li>\r\n \t<li>9.4.3. Syllogistics / Theory of syllogisms</li>\r\n \t<li>9.4.4. Algorithmic and non-algorithmic complexity</li>\r\n \t<li>9.4.5. Urban sociology</li>\r\n \t<li>9.4.6. Investigation in private and public archives</li>\r\n \t<li>9.4.8. Science and technology in contemporary society</li>\r\n \t<li>9.4.9. Anthropology: nascence, development and contemporary trends</li>\r\n \t<li>9.4.10. Culture and civilisation</li>\r\n \t<li>9.4.11. The game as a cultural phenomenon</li>\r\n \t<li>9.4.12. Theory of scientific knowledge</li>\r\n \t<li>9.4.13. Migration studies</li>\r\n \t<li>9.4.14. Religious map of the secular europe today: social-anthropological profile today</li>\r\n \t<li>9.4.15. Social macrotransformation in Bulgaria \u2013 problems and risks</li>\r\n \t<li>9.4.16. Society and environment</li>\r\n \t<li>9.4.17. Philosophy of artificial intellingence</li>\r\n \t<li>9.4.18. Applied process ontology</li>\r\n \t<li>9.4.19. Social problems of deviant behavior</li>\r\n \t<li>9.4.20. Social survey research</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">Other educational initiatives:</p>\r\n\r\n<ul>\r\n \t<li style=\"text-align: justify;\">Intensification of the research interactions between the institutes of BAS and the higher education institutions under the regional academic cooperation schemes;</li>\r\n \t<li style=\"text-align: justify;\">Developing and conducting lecture programmes and courses for higher education institutions in Bulgaria - mainly for Master and PhD students;</li>\r\n \t<li style=\"text-align: justify;\">Increasing the influence and significance of Bulgarian science internationally;</li>\r\n \t<li style=\"text-align: justify;\">Introducing new knowledge and ideas for the benefit of society and research;</li>\r\n</ul>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Philosophy and Sociology","post_link":"https://www.bas.bg/?page_id=24539&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Philosophy and Sociology\" width=\"293\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2020/02/ifs_logo_en-293x300.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_07d104f090f9b6b727231662ddc1eb52%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://issk-bas.org/","%_gallery_link_target%":"_blank","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.696970","%_wpgmp_metabox_longitude%":"23.327790","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Philosophy and Sociology","%acf_bas_fax%":"+359 2 981 7946","%acf_bas_email%":"<a href=\"mailto:iphs.bas@gmail.com\">iphs.bas@gmail.com</a>","%acf_bas_latitude%":"42.696970","%acf_bas_longtitude%":"23.327790","%acf_bas_projects%":"2512, 2502, 2493, 2478, 2470","%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":601,\"to_translate\":{\"en\":601}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"28950","%_edit_lock%":"1581262633:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443051","%avada_post_views_count%":"1831","%avada_today_post_views_count%":"5","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24539,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute of Art Studies","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Art Studies\" width=\"300\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/07/IIIzk_Logo_bg-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute of Art Studies</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 21 Krakra Str., 1504 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 944 2414</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://artstudies.bg\" target=\"_blank\" rel=\"noopener\">http://artstudies.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24495&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.692209","lng":"23.336412","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24495&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"21 Krakra Str., 1504 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 944 2414","%acf_bas_site%":"<a href=\"http://artstudies.bg\" target=\"_blank\" rel=\"noopener\">http://artstudies.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/07/IIIzk_Logo_bg-300x300.jpg\" alt=\"\" width=\"300\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]F[/fusion_dropcap]ounded in 1947, the <strong>Institute of Art Studies</strong> was headed by Academician Ivan Lazarov. In 1988, it merged with the Institute of Music under the title Institute of Art Studies. Its research activities include research in the field of theory and history of fine arts, musical folklore, musicology, theater, cinema and television. Nowadays, the Institute is the only specialized research institution in Bulgaria for studies in the field of ancient, medieval and contemporary art and culture.</p><p style=\"text-align: justify;\">The mission of the Institute is to explore the issues of arts, architecture and culture in a regional, European and global context; to study and rationalize cultural heritage and national identity.</p><p style=\"text-align: justify;\">Outstanding scientific achievements for 2015 and 2016:</p><p style=\"text-align: justify;\">Kuyumdzhiev, A. The murals in the main church of the Rila Monastery. Institute of Art Studies - BAS, 2015, ISBN: 978-954-8594-39, 720 pp.; Biks, R., A. Yaneva, R. Krakostova, M. Tzenova. Bulgarian musical theatre. 1890-2001. Opera, ballet, operetta, musical. Theatres, troupes, performances. 1890 - 2010. Reviews, responses, comments. IV. Gea-Libris - Institute of Art Studies - BAS, 2015, ISBN: 978-954-300-149-1, 768 pp.; Yordanov, N. Bulgarian Theater 1989 - 2015. IAS / Homo Ludens Foundation, S., 2016. ISBN: 978-954-8594-61-5 / 978-619-90678-0-2.</p><p style=\"text-align: justify;\">Best Scientific Achievements for 2015 and 2016:</p><p style=\"text-align: justify;\">A Platform for Arts, electronic edition for authors\u2019 operational critique by scholars and specialists in the field of art and cultural studies; artistic events organized by the Institute of Art Studies in 2016 under the Art Hour initiative.</p><p style=\"text-align: justify;\">The Institute has established contacts with George Oprescu Institute of Art History at the Romanian Academy, the Center for the Study of Arts at the Institute of Cultural Heritage of the Academy of Sciences of Moldova and the Institute of Art Studies, Folklore and Ethnology at the National Academy of Sciences of Ukraine, the Institute of Theater and Film Research at the Slovak Academy of Sciences and others. The Institute and the University of Belgrade, Department of History of Art, have concluded a three-year bilateral agreement on academic exchanges and educational cooperation. This agreement creates very good opportunities for mutual visits of students and PhD students, conducting research by Bulgarian and Serbian scientists, participation in conferences and joint scientific publications, library exchange, research projects.</p><p style=\"text-align: justify;\">The Institute owns the unique on the Balkans Japanese laser gramophone ELP Laser Turntable LT-2XRC with the help of which information from old, damaged or broken gramophone records can be downloaded without contact that can be digitized and mastered; an archive of 100 000 photos, a text archive of over 250 000 pages, an audio archive of over 3400 tapes and 1800 records and a video archive of 800 films and over 200 video tapes containing unique data; a library fund of 50 000 volumes, including rare editions of the late 19th century.</p><p style=\"text-align: justify;\">The Scientific Council of the Institute of Art Studies, at its meeting held on 28.10.2016 (Protocol 9, item 19), established an Annual Animated Heritage Award - for contributions to the creative interpretation of the traditions and values of the Bulgarian and world cultural heritage in a contemporary work or works of art.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p></p>[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>International relations</p>[/fusion_title][fusion_checklist icon=\"fa-random\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://www.uai-iua.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Union Academique Internationale</a>\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"\"]\r\n\r\n<a href=\"http://aicafrance.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Association Internationale des critiques d`art</a>\r\n\r\n[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute of Art Studies","post_link":"https://www.bas.bg/?page_id=24495&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute of Art Studies\" width=\"300\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/07/IIIzk_Logo_bg-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"default","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_7ac50f2f9847468db71b09f83b0a806b%":"{{unknown}}","%_oembed_28a3651c72fabd629b9e1caa1ea291d5%":"{{unknown}}","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.692209","%_wpgmp_metabox_longitude%":"23.336412","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute of Art Studies","%acf_bas_fax%":"+359 2 943 3092","%acf_bas_email%":"<a href=\"mailto:office@artstudies.bg\">office@artstudies.bg</a>","%acf_bas_latitude%":"42.692209","%acf_bas_longtitude%":"23.336412","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpmf_gallery_custom_image_link%":"http://aicafrance.org/","%_gallery_link_target%":"_blank","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":569,\"to_translate\":{\"en\":569}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16511","%_edit_lock%":"1563110238:18","%_edit_last%":"18","%pyre_demo_slider%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_last_translation_edit_mode%":"native-editor","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443047","%avada_post_views_count%":"571","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24495,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute for Historical Studies","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for Historical Studies\" width=\"293\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/07/IIstI-BAN-293x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute for Historical Studies</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 52 Shipchenski Prohod Blvd., Bl. 17, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 870 2191</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.ihist.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.ihist.bas.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24485&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.677354","lng":"23.366380","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24485&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"52 Shipchenski Prohod Blvd., Bl. 17, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 870 2191","%acf_bas_site%":"<a href=\"http://www.ihist.bas.bg/\" target=\"_blank\" rel=\"noopener\">http://www.ihist.bas.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><a href=\"https://www.bas.bg/wp-content/uploads/2019/09/IHistS-BAS.jpg\"><img class=\"wp-image-25450 size-medium alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2019/09/IHistS-BAS-285x300.jpg\" alt=\"\" width=\"285\" height=\"300\" /></a>[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute for Historical Studies</strong> is the main scientific center for fundamental and specialized research in the field of history and the training of highly qualified specialists. Research is conducted in the sphere of Bulgarian history from antiquity to modernity, European and world issues, genealogy, archaeography, etc.</p>\r\n<p style=\"text-align: justify;\">The Institute is one of the oldest units of BAS. With the Law on the Bulgarian Academy of Sciences and Arts of 1940, the study of Bulgarian history became a priority for the oldest Bulgarian scientific organization. In 1947, an Institute for Bulgarian History was established at the Historical-Philological branch, headed by Academician Ivan Snegarov. In the context of the reforms at BAS in 2010, the present title of the Institute was adopted. The Academicians G. Katsarov, P. Nikov, K. Kossev, G. Markov, the Professors I. Undjiev, B. Tsvetkova, E. Grozdanova, V. Paskaleva and others have enriched Bulgarian and world historical science with their studies and have received international recognition.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">The Institute for Historical Studies studies the theoretical and special problems of our national political, social, religious and cultural history from the creation of the Bulgarian state to the present day as well as issues of world history and international relations. The comparative historical research on the role and place of Bulgaria in the world historical process, the contribution of the Bulgarian nation in the cultural treasury of humanity are main areas of the scientific activity of the Institute for Historical Studies.</p>\r\n<p style=\"text-align: justify;\">The multi-volume edition of the Institute \"Sources for Bulgarian History\" includes Greek, Latin, Turkish, Jewish and others sources and is used by significant historical studies in Bulgaria and abroad. The multi-volume \"History of Bulgaria\" reflects the Bulgarian and foreign achievements in this sphere. Scholars from the Institute are publishing \"History of the BAS\" and are contributing, with monographs and other studies, to the research on the development of Bulgaria within the common European and world trends and the leading processes in world history. The Institute members currently collaborate with prestigious science centers in the European Union, the United States, Russia and China. The Institute publishes two of the most prestigious scientific journals in Bulgaria in the field of historical research: \"Bulgarian Historical Review\" and \"Historical Review\".</p>\r\n<p style=\"text-align: justify;\">The seminar \"Current Problems of History and Historiography\" is held every month since 2013 in Bulgarian and other major European languages. The purpose of the seminar is to respond to the interest of society in historical knowledge. The lectures, delivered by scholars from the Institute for Historical Studies and other Bulgarian and European scientific institutions, are devoted to important issues of Bulgarian and world history and historiography. The seminar is the leading center of dissemination and popularization of the achievements of historical science.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Doctoral (PhD) Programs:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Doctoral programme \"Medieval general history\", professional field 2.2. History and Archaeology of area 2. Humanities in Higher Education;</li>\r\n \t<li>Doctoral programme \"New and newest general history\", professional field 2.2. History and Archaeology of area 2. Humanities in Higher Education;</li>\r\n \t<li>Doctoral programme \"History of Bulgaria\", professional field 2.2. History and Archaeology of area 2. Humanities in Higher Education;</li>\r\n \t<li>Doctoral programme \"Documentation and archival science, palaeography (including historiography and source studies)\", professional field 2.2. History and Archaeology of area 2. Humanities in Higher Education.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">For the five-year period from 2013 to 2016, ten PhD students successfully defended their doctoral theses. In 2017, twelve PhD students were trained at the Institute for Historical Studies.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Other educational initiatives</h6>\r\n<p style=\"text-align: justify;\">Scholars from the Institute for Historical Studies perform teaching activities at the Training Center of the Bulgarian Academy of Sciences and at various higher education institutions in the country. In connection with the implementation of the project \"Student Practices\", financed by the Operational Program \"Human Resources Development\", co-financed by the European Social Fund, the Institute for Historical Studies concluded, in 2013, contracts for organizing student research internships with six higher education institutions from the country: Sofia University \"St. Kliment Ohridski\", UNWE, New Bulgarian University, ULSIT, SWU \"Neofit Rilski\" and International Business School.</p>\r\n<p style=\"text-align: justify;\">The Institute of Ethnology and Folklore Studies with Ethnographic Museum at BAS is a leading national scientific institution in the field of ethnology and folklore studies whose aim is to support the knowledge and the consciousness of the society about traditions and cultural identity and their role in the contemporary world. The scholars and specialists are engaged in the study and analysis of Bulgaria's multispectral cultural history and present-day history, cultural phenomena and processes in Balkan, European and world contexts. Through the activities of the National Center for Intangible Cultural Heritage and the National Ethnographic Museum, the cultural heritage is systematically searched, collected, preserved and presented.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p></p>[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute for Historical Studies","post_link":"https://www.bas.bg/?page_id=24485&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for Historical Studies\" width=\"293\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/07/IIstI-BAN-293x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_wpmf_gallery_custom_image_link%":"http://www.ihist.bas.bg/","%_gallery_link_target%":"_blank","%pyre_wooslider%":"","%_oembed_74b8175c48c32a45de4817ff13407af5%":"{{unknown}}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.677354","%_wpgmp_metabox_longitude%":"23.366380","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute for Historical Studies","%acf_bas_fax%":"+359 2 870 8513","%acf_bas_email%":"<a href=\"mailto:ihistory@ihist.bas.bg\">ihistory@ihist.bas.bg</a>","%acf_bas_latitude%":"42.677354","%acf_bas_longtitude%":"23.366380","%acf_bas_projects%":"3165, 3153, 3132","%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":670,\"to_translate\":{\"en\":670}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16244","%_edit_lock%":"1568218583:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443043","%avada_post_views_count%":"728","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"21-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24485,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute for Literature","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for Literature\" width=\"300\" height=\"216\" src=\"https://www.bas.bg/wp-content/uploads/2017/07/Logo_2-300x216.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute for Literature</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 52 Shipchenski Prohod Blvd., Bl. 17, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 971 7056</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://www.ilit.bas.bg/bg/\" target=\"_blank\" rel=\"noopener\">http://www.ilit.bas.bg/bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24473&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.67732","lng":"23.36636","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24473&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"52 Shipchenski Prohod Blvd., Bl. 17, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 971 7056","%acf_bas_site%":"<a href=\"http://www.ilit.bas.bg/bg/\" target=\"_blank\" rel=\"noopener\">http://www.ilit.bas.bg/bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/07/Logo_2-300x216.jpg\" alt=\"\" width=\"300\" height=\"216\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute for Literature at the Bulgarian Academy of Sciences</strong> is a national center for the study of Bulgarian literature from the Middle Ages to the present day in a theoretical, historical, cultural and comparative aspect. The main research areas at the Institute for Literature are Old Bulgarian literature, literature of the Bulgarian Revival, new and modern Bulgarian literature, theory of literature, comparative literary studies.</p><p style=\"text-align: justify;\">The main task of the Institute is to understand, preserve and promote the Bulgarian literary and cultural heritage in the context of the European humanitarian traditions. In a wide and multifaceted international collaboration, it takes the form of academic collective and monographic studies of literary history and theory, studies on the work of Bulgarian writers, compilation of encyclopaedic and reference books, creation of electronic databases and digital libraries, search, safeguarding and publication of archives and archival materials, preparation of multi-volume academic publications of Bulgarian writers.</p><p style=\"text-align: justify;\">The long-standing scientific research experience and the scientific potential of the Institute allow the realization of fundamental scientific projects that require teamwork of highly qualified specialists. Their scientific achievements are recognized in the national and international humanitarian community.</p><p style=\"text-align: justify;\">Literary-historical and comparative studies are conducted at the Institute for Literature and general theoretical works are developed aimed at studying the Bulgarian literary heritage which is representative of the contribution of Bulgarian culture to the world civilization. The scientific activity is carried out with modern scientific approaches and with the means of modern technologies. Their use makes it possible to combine academic precision and in-depth studies with the practical applicability of science, to prepare digital resources that respond to the contemporary demands of society. The wide availability and high quality of the scientific products created in the Institute help to form a new type of thinking and the building of ethical values \u200b\u200bthrough the rationalization of the past and outlining prospects for the future.</p><p style=\"text-align: justify;\">Part of the research efforts of the Institute are aimed at exploring and investigating unknown or little-known literary-historical facts and their contemporary interpretation in order to outline the essence and the directions of the literary phenomena and to trace the interactions and polemics in the Bulgarian culture. In these studies, the documentary basis and the scientific approach are in an organic synthesis, and literary history is represented as a system of aesthetic and ethical values \u200b\u200bwhich, in new exploratory contexts, create fruitful cultural dialogues. Thus, the field of the literary studies is expanding, and the Institute is becoming a center of comparative research. In its research activities, a considerable part has also been devoted to previously neglected areas such as emigration literature, minority literature in Bulgaria and abroad, anti-totalitarian literature, parallel aesthetic processes in the Bulgarian and other Balkan and European literatures. The realization of such projects, which are fundamental for the contemporary humanities, is realized through the creation of interdisciplinary consortia of which the Institute for Literature is a coordinator.</p><p style=\"text-align: justify;\">Archives and documents are searched for, preserved, studied and published. Unique encyclopaedic and reference books such as \"Cyrillo-Methodian Encyclopaedia\" (4 volumes), \"Dictionary of Bulgarian Literature\" (3 volumes), \"Dictionary of New Bulgarian Literature\", \"Periodicals and Literature (6 volumes), \"Reception of the European Literatures translated in Bulgarian\" (6 volumes), \"Periodicals of Russian Emigration in Bulgaria\", the Encyclopaedia \"Bulgarian Revival. Literature. Periodicals publishing. Literary life. Cultural centers\" (in 3 volumes), Literary archive (9 volumes), \"Critical Heritage of Bulgarian Modernism\" (4 volumes). Thirty-nine interviews with prominent Bulgarian writers and critics have been published. The publishing house \"Boyan Penev\" has been established at the Institute which publishes scientific collections and monographs in the field of humanities.</p><p style=\"text-align: justify;\">The Institute for Literature preserves:</p><ul style=\"text-align: justify;\"><li>Part of the literary archives of Nikola Vaptsarov, Hristo Smirnenski, Mihalaki Georgiev, Hristo Ognyanov;</li><li>The personal libraries of the Bulgarian writers Asen Raztsvetnikov, Nikolay Liliev, Stefan Kozhuharov;</li><li>An archive of photographs of Bulgarian writers and cultural figures.</li></ul><p style=\"text-align: justify;\">Prominent scholars have worked at the Institute for Literature such as Academician Mihail Arnaudov, Acad. Nikolay Liliev, Acad. Petar Dinekov, Acad. Emil Georgiev, Acad. Panteley Zarev, corr.-mem. Milena Tsaneva, Prof. DSc Atanas Natev, Prof. DSc Boyan Nichev, Assoc. Prof. Dr. Yordan Vasilev, Prof. Dr. Iliya Konev, Prof. DSc Docho Lekov, Prof. Dr. Zdravko Petrov, Prof. DSc Elka Konstantinova, Prof. Dr. Krastyo Kuyumdzhiev, Prof. Wanda Smochovska-Petrova, Prof. DSc Ivan Sarandev and others.</p><p style=\"text-align: justify;\">Scholars from the Institute for Literature were awarded:</p><ul><li style=\"text-align: justify;\">Big Pythagoras Award for 2008 for best scientific team headed by Prof. DSc Anisava Miltenova for the project \u201cRepertorium of Old Bulgarian Literature and Letters with Computer Tools\u201d;</li><li style=\"text-align: justify;\">Pythagoras Award for 2008 for a recognized scholar in the social sciences and humanities for Prof. Dr. Rumyana Damyanova;</li><li style=\"text-align: justify;\">Pythagoras Award for 2009 for a recognized scholar in the social sciences and humanities for Assoc. Prof. DSc Radosvet Kolarov;</li><li style=\"text-align: justify;\">Pythagoras Award for a recognized scholar in the field of social sciences and humanities for a significant contribution to the development of science in the category in the period 2013-2014 for Prof. Dr. Dorotej Getov.</li></ul>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute for Literature","post_link":"https://www.bas.bg/?page_id=24473&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for Literature\" width=\"300\" height=\"216\" src=\"https://www.bas.bg/wp-content/uploads/2017/07/Logo_2-300x216.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_efab6ace27226575c02df73f0922c302%":"{{unknown}}","%pyre_wooslider%":"","%_oembed_41ebbf0918bf94a0b20ca27f31e0ec7e%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://www.ilit.bas.bg/bg/","%_gallery_link_target%":"_blank","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.67732","%_wpgmp_metabox_longitude%":"23.36636","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute for Literature","%acf_bas_fax%":"+359 2 971 7056","%acf_bas_email%":"<a href=\"mailto:director@ilit.bas.bg\">director@ilit.bas.bg</a>","%acf_bas_latitude%":"42.67732","%acf_bas_longtitude%":"23.36636","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":837,\"to_translate\":{\"en\":837}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16461","%_edit_lock%":"1563101690:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443043","%avada_post_views_count%":"692","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24473,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"National Archaeological Institute with Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Archaeological Institute with Museum\" width=\"227\" height=\"65\" src=\"https://www.bas.bg/wp-content/uploads/2017/07/logo_NAIM_years.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">National Archaeological Institute with Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 2 Saborna Str., 1000 Sofia</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 988 24 06</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://naim.bg/\" target=\"_blank\" rel=\"noopener\">http://naim.bg/</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24501&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.696507","lng":"23.324506","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24501&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"2 Saborna Str., 1000 Sofia","%acf_bas_phone%":"+359 2 988 24 06","%acf_bas_site%":"<a href=\"http://naim.bg/\" target=\"_blank\" rel=\"noopener\">http://naim.bg/</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"1\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"none\" sep_color=\"\"][acf field=\"acf_bas_deptname\"][/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/07/logo_NAIM_years.jpg\" alt=\"\" width=\"283\" height=\"81\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he National Archaeological Institute with Museum at BAS (NAIM-BAS)</strong> works on the overall study of the material and spiritual culture of the tribes and peoples who inhabited present-day\u2019s Bulgarian lands from the deepest antiquity to the 18th century.</p>\r\n\r\n<blockquote>\r\n<p style=\"text-align: justify;\">NAIM-BAS is a national center and coordinator of all field archaeological research on the territory of Bulgaria and performs scientific and methodological control over them.</p>\r\n</blockquote>\r\n<p style=\"text-align: justify;\">The Archaeological Museum is the largest in Bulgaria and with its expositions is one of the most important centers in the country for popularizing the past of present-day\u2019s Bulgarian lands. With its scientific and museum potential, NAIM-BAS is the largest scientific institution for archaeology in Southeastern Europe.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Scientific activity</h6>\r\n<p style=\"text-align: justify;\">Taking into consideration the specifics of the studied issues, the National Archaeological Institute with Museum - BAS includes the following scientific structural units:</p>\r\n\r\n<ul style=\"text-align: justify;\">\r\n \t<li>Five chronologically and thematically profiled sections: Department of Prehistory, Department of Thracian Archaeology, Department of Classic Archaeology, Department of Medieval Archaeology, Department of Numismatics &amp; Epigraphy;</li>\r\n \t<li>Department of Interdisciplinary Research and Archaeological Map of Bulgaria;</li>\r\n \t<li>Two branches for studying the ancient Bulgarian capitals (in Shumen and Veliko Tarnovo);</li>\r\n \t<li>Archaeological Museum with three departments: Expositions, Repositories and Laboratory for Analyses, Conservation and Restoration.</li>\r\n</ul>\r\n<p style=\"text-align: justify;\">The various activities of NAIM-BAS are carried out in close cooperation and interaction with the museums in the country, state institutions (Ministry of Culture, Ministry of Education and Science, National Institute of Immovable Cultural Heritage), regional and local executive bodies and various non-governmental organizations.</p>\r\n<p style=\"text-align: justify;\">The fieldwork of scientists and specialists from NAIM-BAS includes regular and rescue archaeological excavations, field searches and observations and is carried out on more than 100 archaeological sites, chronologically covering the time from the early Paleolithic to the late Ottoman epoch.</p>\r\n<p style=\"text-align: justify;\">The scientifically applied activity of NAIM-BAS is expressed mainly in various events related to the specifics of functioning of the Archaeological Museum - inventory of museum funds, inventory of new materials, preparation and presentation of permanent and temporary expositions, restoration, preservation and photo-documentation, updating of the museum records.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Educational activity</h6>\r\n<p style=\"text-align: justify;\">Doctoral programs</p>\r\n<p style=\"text-align: justify;\">A major element in the educational activity of NAIM is the training of PhD students in the field of archaeology through the PhD program. In 2017, 10 PhD students were trained at NAIM-BAS.</p>\r\n<p style=\"text-align: justify;\">Other educational initiatives</p>\r\n<p style=\"text-align: justify;\">The educational activities of NAIM-BAS include conducting lectures and exercises in all higher education institutions where archaeology is studied, the preparation of graduates, the organization of field student practices. A particular emphasis in the work of the museum in recent years is the work with groups of pupils and preschool children. Annual initiatives are \u201eSchool in the Museum\u201d, \u201eSummer in the Museum\u201d and other museum and educational program\u043f\u0435s on history and ancient art in relation to permanent and temporary exhibitions.</p>\r\n\r\n<h6 style=\"text-align: justify;\">Brief history</h6>\r\n<ul>\r\n \t<li style=\"text-align: justify;\">On 8 November 1878, Sofia Public Library was established.</li>\r\n \t<li style=\"text-align: justify;\">On 5 June 1879 it was renamed Bulgarian National Library in Sofia.</li>\r\n \t<li style=\"text-align: justify;\">On 1 January 1893 the National Museum was established as a separate institution.</li>\r\n \t<li style=\"text-align: justify;\">In 1901, the Bulgarian Archaeological Society was founded.</li>\r\n \t<li style=\"text-align: justify;\">With the promulgation of the Law on National Enlightenment in 1909, the National Museum was renamed People's Archaeological Museum.</li>\r\n \t<li style=\"text-align: justify;\">In 1920, on the basis of the Bulgarian Archaeological Society, the Bulgarian Archaeological Institute was established as a separate scientific institution.</li>\r\n \t<li style=\"text-align: justify;\">By a decision of the Executive Council of BAS, legalized by a decree of the Council of Ministers signed on 3 November 1948, the National Archaeological Museum merged with the Archaeological Institute under the common name Archaeological Institute and Museum at BAS.</li>\r\n</ul>\r\n[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker-alt fas\"][acf field=\"acf_bas_address\"][/fusion_li_item][fusion_li_item icon=\"fa-phone-square fas\"][acf field=\"acf_bas_phone\"][/fusion_li_item][fusion_li_item icon=\"fa-fax fas\"][acf field=\"acf_bas_fax\"][/fusion_li_item][fusion_li_item icon=\"fa-at fas\"][acf field=\"acf_bas_email\"][/fusion_li_item][fusion_li_item icon=\"fa-sitemap fas\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"National Archaeological Institute with Museum","post_link":"https://www.bas.bg/?page_id=24501&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Archaeological Institute with Museum\" width=\"227\" height=\"65\" src=\"https://www.bas.bg/wp-content/uploads/2017/07/logo_NAIM_years.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_demo_slider%":"","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_wpmf_gallery_custom_image_link%":"http://naim.bg/","%_gallery_link_target%":"_blank","%pyre_wooslider%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.696507","%_wpgmp_metabox_longitude%":"23.324506","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"National Archaeological Institute with Museum","%acf_bas_fax%":"+359 2 988 24 05","%acf_bas_email%":"<a href=\"mailto:naim@naim.bg\">naim@naim.bg</a>","%acf_bas_latitude%":"42.696507","%acf_bas_longtitude%":"23.324506","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%_oembed_9da4cb773e22699ebd8dabdfb4cbb753%":"{{unknown}}","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":602,\"to_translate\":{\"en\":602}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_edit_lock%":"1563110138:18","%_edit_last%":"18","%_last_translation_edit_mode%":"native-editor","%_thumbnail_id%":"16230","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443047","%avada_post_views_count%":"707","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24501,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Institute for Bulgarian Language &#8220;Prof. Lubomir Andreychin&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for Bulgarian Language &#8220;Prof. Lubomir Andreychin&#8221;\" width=\"300\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/02/IBL_Logo_jpg-e1512744253539-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Institute for Bulgarian Language &#8220;Prof. Lubomir Andreychin&#8221;</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 52 Shipchenski Prohod Blvd., Bl. 17, 1113 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 2940</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://ibl.bas.bg\" target=\"_blank\" rel=\"noopener\">http://ibl.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24466&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","address":"\u0418\u043d\u0441\u0442\u0438\u0442\u0443\u0442 \u0437\u0430 \u0431\u044a\u043b\u0433\u0430\u0440\u0441\u043a\u0438 \u0435\u0437\u0438\u043a \u043a\u044a\u043c \u0411\u0410\u041d, \u0421\u043e\u0444\u0438\u044f, \u0411\u044a\u043b\u0433\u0430\u0440\u0438\u044f","location":{"lat":"42.67731999999999","lng":"23.366359999999986","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24466&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"52 Shipchenski Prohod Blvd., Bl. 17, 1113 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 2940","%acf_bas_site%":"<a href=\"http://ibl.bas.bg\" target=\"_blank\" rel=\"noopener\">http://ibl.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]<p style=\"text-align: justify;\"><img class=\"alignleft\" src=\"/wp-content/uploads/2017/02/IBL_Logo_jpg-300x300.jpg\" alt=\"\" width=\"300\" height=\"300\" />[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Institute for Bulgarian Language \"Prof. Lubomir Andreychin\"</strong> was founded on 15 May 1942 as a Bulgarian Dictionary Service at the Bulgarian Academy of Sciences. In 1947, the Bulgarian Dictionary Service grew into the Institute for Bulgarian Dictionary, and in 1949 - into the Institute for Bulgarian Language.</p><p style=\"text-align: justify;\">The history of the Institute is intertwined with the life and creative work of great Bulgarian linguists and marks serious scientific achievements in the field of linguistic Bulgarian studies. Head of the Bulgarian Dictionary Service and first director of the Institute for Bulgarian Language (1947 - 1951) was Academician S. Romanski. Other prominent scientists whose professional path was closely related to the Institute, are: Academician Vladimir Georgiev, Academician Stefan Mladenov, Academician Valentin Stankov, Academician Ivan Duridanov, corr-member Lubomir Andreychin, corr.-mem. Kiril Mirchev, Art. Dora Ivanova-Mircheva, Prof. Yordan Zaimov, Prof. Stoyko Stoykov, Prof. Ivan Lekov, Prof. Kristalina Cholakova, Prof. Yordan Penchev and many others.</p><h6 style=\"text-align: justify;\">Scientific activity</h6><p style=\"text-align: justify;\">The priority research areas of the Institute are:</p><ul style=\"text-align: justify;\"><li>The academic dictionaries of Bulgarian language;</li><li>Bulgarian cultural and linguistic heritage;</li><li>Theoretical linguistic research;</li><li>Electronic language resources and language technologies.</li></ul><p style=\"text-align: justify;\">The main lexicographical work of the Institute for Bulgarian Language is the multi-volume \"Dictionary of Bulgarian Language\" - the largest and most representative dictionary of the kind that includes 119 229 headers and reflects the modern state and development of the Bulgarian language since the beginning of the 19th century. Among the most significant achievements of the Institute are: the multi-volume \"Bulgarian etymological dictionary\" explaining the origin of the words in the Bulgarian language and its relations with other Balkan, Slavic and Indo-European languages; the two-volume \"Old Bulgarian Dictionary\" - a translative and interpretative vocabulary of the classical Glagolitic and Cyrillic written monuments; \"Bulgarian Dialectical Atlas. Summarizing volume. Phonetics. Accentology. Lexis. Morphology\"- 503 dialectal maps which represent and compare language facts based on a material of 2 300 settlements in which dialects of the Bulgarian language are spoken. More important spelling dictionaries of the Institute are: \"Spelling Dictionary of the Modern Bulgarian Literary Language\" (1983), \"Official Spelling Dictionary of the Bulgarian Language\" (2012), \"Official Spelling Dictionary of the Bulgarian Language. Verbs\" (2016).</p><p style=\"text-align: justify;\">The three-volume \"Grammar of the Modern Bulgarian Literary Language\" is the first academic grammar which presents the phonetic, morphological and syntactic structure of the Bulgarian language exhaustively. The work \"Bulgarian Lexicology and Phraseology\" (v. I - III) is a summary study describing the lexical and phrasaeological system of the Bulgarian language.</p><h6 style=\"text-align: justify;\">Educational activity</h6><p style=\"text-align: justify;\">Accredited by NEAA scientific specialties for the training of PhD students at the Institute for Bulgarian Language in the professional field \"Philology\", code 2.1, are: \"Bulgarian language\" and \"General and comparative linguistics\".</p><p style=\"text-align: justify;\">The Institute for Bulgarian Language at BAS accepts for training Bulgarian and foreign graduates, offers Bulgarian language training as foreign to foreign students and citizens and specialized courses for Bulgarian language teachers at school.</p>[/fusion_text][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>Contacts</p>[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-fax\"]\r\n\r\n[acf field=\"acf_bas_fax\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]<p>International relations</p>[/fusion_title][fusion_checklist icon=\"fa-random fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]<a href=\"http://www.meta-net.eu\" target=\"_blank\" rel=\"noopener noreferrer\">A Network of Excellence forging the Multilingual Europe Technology Alliance (META-NET)</a>[/fusion_li_item][fusion_li_item icon=\"\"]<a href=\"http://www.efnil.org/\" target=\"_blank\" rel=\"noopener noreferrer\">European Federation of National Institutions for Language (EFNIL)</a>[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Institute for Bulgarian Language &#8220;Prof. Lubomir Andreychin&#8221;","post_link":"https://www.bas.bg/?page_id=24466&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Institute for Bulgarian Language &#8220;Prof. Lubomir Andreychin&#8221;\" width=\"300\" height=\"300\" src=\"https://www.bas.bg/wp-content/uploads/2017/02/IBL_Logo_jpg-e1512744253539-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_sticky%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_line_height%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%fusion_builder_status%":"active","%kd_featured-image-2_page_id%":"","%kd_featured-image-3_page_id%":"","%kd_featured-image-4_page_id%":"","%kd_featured-image-5_page_id%":"","%_oembed_10f91c9ded314aaf5d1e74f8d0897a95%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://ibl.bas.bg","%_gallery_link_target%":"_blank","%pyre_wooslider%":"","%_wpgmp_location_address%":"\u0418\u043d\u0441\u0442\u0438\u0442\u0443\u0442 \u0437\u0430 \u0431\u044a\u043b\u0433\u0430\u0440\u0441\u043a\u0438 \u0435\u0437\u0438\u043a \u043a\u044a\u043c \u0411\u0410\u041d, \u0421\u043e\u0444\u0438\u044f, \u0411\u044a\u043b\u0433\u0430\u0440\u0438\u044f","%_wpgmp_metabox_latitude%":"42.67731999999999","%_wpgmp_metabox_longitude%":"23.366359999999986","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Institute for Bulgarian Language \"Prof. Lubomir Andreychin\"","%acf_bas_fax%":"+359 2 872 2302","%acf_bas_email%":"<a href=\"mailto:ibl@ibl.bas.bg\">ibl@ibl.bas.bg</a>","%acf_bas_latitude%":"42.67731999999999","%acf_bas_longtitude%":"23.366359999999986","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":593,\"to_translate\":{\"en\":593}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"16147","%_edit_lock%":"1563100771:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443043","%avada_post_views_count%":"319","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24466,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Research Unit","id":"7","type":"category"}]},{"source":"post","title":"Training Center of BAS","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n\t<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Training Center of BAS\" width=\"295\" height=\"295\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/mod_obuchenie2.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    \t<div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n        \t<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Training Center of BAS</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Address: 4 Serdica Str., 1000 Sofia, Bulgaria</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Telephone: +359 2 979 52 60</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">Website: <a href=\"http://edu.bas.bg\" target=\"_blank\" rel=\"noopener\">http://edu.bas.bg</a></div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\"><a href=\"https://www.bas.bg/?page_id=24593&lang=en\">See more...</a></div>\r\n         </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>    \r\n</div>\r\n","location":{"lat":"42.69821","lng":"23.324880000000007","onclick_action":"marker","redirect_permalink":"https://www.bas.bg/?page_id=24593&lang=en","zoom":14,"extra_fields":{"%acf_bas_address%":"4 Serdica Str., 1000 Sofia, Bulgaria","%acf_bas_phone%":"+359 2 979 52 60","%acf_bas_site%":"<a href=\"http://edu.bas.bg\" target=\"_blank\" rel=\"noopener\">http://edu.bas.bg</a>","post_excerpt":"","post_content":"[fusion_builder_container hundred_percent=\"no\" equal_height_columns=\"no\" menu_anchor=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"center center\" background_repeat=\"no-repeat\" fade=\"no\" background_parallax=\"none\" parallax_speed=\"0.3\" video_mp4=\"\" video_webm=\"\" video_ogv=\"\" video_url=\"\" video_aspect_ratio=\"16:9\" video_loop=\"yes\" video_mute=\"yes\" overlay_color=\"\" video_preview_image=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" padding_top=\"\" padding_bottom=\"\" padding_left=\"\" padding_right=\"\"][fusion_builder_row][fusion_builder_column type=\"2_3\" layout=\"1_1\" background_position=\"left top\" background_color=\"\" border_size=\"\" border_color=\"\" border_style=\"solid\" border_position=\"all\" spacing=\"yes\" background_image=\"\" background_repeat=\"no-repeat\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"0px\" margin_bottom=\"0px\" class=\"\" id=\"\" animation_type=\"\" animation_speed=\"0.3\" animation_direction=\"left\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" center_content=\"no\" last=\"no\" min_height=\"\" hover_type=\"none\" link=\"\"][fusion_title margin_top=\"\" margin_bottom=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" size=\"1\" content_align=\"left\" style_type=\"none\" sep_color=\"\"]\r\n\r\n[acf field=\"acf_bas_deptname\"]\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n<p style=\"text-align: justify;\"><a href=\"http://edu.bas.bg/\" target=\"_blank\" rel=\"noopener noreferrer\"><img class=\"alignleft\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/mod_obuchenie2.png\" alt=\"\" width=\"295\" height=\"295\" /></a>[fusion_dropcap boxed=\"no\" boxed_radius=\"\" class=\"\" id=\"\" color=\"\"]<strong>T</strong>[/fusion_dropcap]<strong>he Training Center of BAS (TC)</strong> was established in January 1997 as a specialized unit of BAS for the preparation of highly qualified scientists through training in the educational and scientific degree \"PhD\" at the scientific units of BAS, for the realization and career development of the scientific potential of the country.</p>\r\n<p style=\"text-align: justify;\">The Center works closely with the institutes of the Academy by organizing and coordinating the admissions competitions for PhD students, organizing the program accreditation of NEAA at all units of BAS, organizing and conducting foreign language training, information technologies training and specialized PhD courses at the Doctoral School of the Center. Pursuant to the new Law on the Development of the Academic Staff in the Republic of Bulgaria, the Training Center verifies the diplomas and keeps a register of the applicants for recognition of the educational and scientific degree \"doctor\" acquired abroad.</p>\r\n<p style=\"text-align: justify;\">The Training Center has well-prepared English and German language teachers, teachers in computer skills as well as up-to-date high-level training facilities.</p>\r\n<p style=\"text-align: justify;\">On 25 May 2015, the Director of the Training Center, Prof. Evdokia Pasheva, opened the new training halls of the TC-BAS at 125, Tsarigradsko Shosse Blvd., bl. 26B, 2 floor. The study rooms are equipped with completely new, modern equipment and furniture. The Center has four new halls: a language training room, a computer training room, multimedia, a conference room with 30 seats and a meeting room with 20 seats. The modern training rooms enable the Training Center to expand its activities in the training of PhD students at a higher European level.</p>\r\n<p style=\"text-align: justify;\">The Training Center takes care not only to organize the specialized training of doctoral students, mainly conducted at the different scientific units, but also for their wider education through seminars, mobility, liaison with appropriate partners, etc. The Career Center at TC annually hosts scientific seminars for PhD students from all the divisions of BAS where they can meet not only with established scientists but also with business representatives.</p>\r\n<p style=\"text-align: justify;\">In April 2016, the Training Center organized and held the first Interdisciplinary PhD forum. It was intended for PhD students who were at a different stage of their research, with the main purpose of exchanging ideas and supporting interdisciplinary thinking.</p>\r\n[/fusion_text][fusion_gallery layout=\"\" picture_size=\"\" columns=\"2\" column_spacing=\"10\" hover_type=\"liftup\" lightbox=\"yes\" lightbox_content=\"title_and_caption\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_gallery_image image=\"\" image_id=\"7902\" /][fusion_gallery_image image=\"\" image_id=\"7900\" /][/fusion_gallery][/fusion_builder_column][fusion_builder_column type=\"1_3\" layout=\"1_3\" spacing=\"\" center_content=\"no\" hover_type=\"none\" link=\"\" min_height=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" background_color=\"\" background_image=\"\" background_position=\"left top\" background_repeat=\"no-repeat\" border_size=\"0\" border_color=\"\" border_style=\"solid\" border_position=\"all\" padding_top=\"\" padding_right=\"\" padding_bottom=\"\" padding_left=\"\" margin_top=\"\" margin_bottom=\"\" animation_type=\"\" animation_direction=\"left\" animation_speed=\"0.3\" animation_offset=\"\" last=\"no\"][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]\r\n\r\nContacts\r\n\r\n[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"fa-map-marker\"]\r\n\r\n[acf field=\"acf_bas_address\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-phone-square\"]\r\n\r\n[acf field=\"acf_bas_phone\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-at\"]\r\n\r\n[acf field=\"acf_bas_email\"]\r\n\r\n[/fusion_li_item][fusion_li_item icon=\"fa-sitemap\"][acf field=\"acf_bas_site\"][/fusion_li_item][/fusion_checklist][fusion_title hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\" content_align=\"left\" size=\"3\" font_size=\"\" line_height=\"\" letter_spacing=\"\" margin_top=\"\" margin_bottom=\"15px\" margin_top_mobile=\"\" margin_bottom_mobile=\"\" text_color=\"\" style_type=\"underline solid\" sep_color=\"\"]Language and computer training halls[/fusion_title][fusion_text columns=\"\" column_min_width=\"\" column_spacing=\"\" rule_style=\"default\" rule_size=\"\" rule_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"]\r\n\r\n\r\n\r\n[/fusion_text][fusion_checklist icon=\"fa-map-marker-alt fas\" iconcolor=\"\" circle=\"\" circlecolor=\"\" size=\"13px\" divider=\"\" divider_color=\"\" hide_on_mobile=\"small-visibility,medium-visibility,large-visibility\" class=\"\" id=\"\"][fusion_li_item icon=\"\"]Acad. Georgi Bonchev Str., Bl. 26B, 1113 Sofia, Bulgaria[/fusion_li_item][/fusion_checklist][/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]","post_title":"Training Center of BAS","post_link":"https://www.bas.bg/?page_id=24593&lang=en","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Training Center of BAS\" width=\"295\" height=\"295\" src=\"https://www.bas.bg/wp-content/uploads/2017/12/mod_obuchenie2.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"100-width.php","%fusion_builder_status%":"active","%pyre_slider_type%":"no","%pyre_slider%":"0","%pyre_wooslider%":"","%pyre_revslider%":"0","%pyre_elasticslider%":"0","%pyre_slider_position%":"default","%pyre_avada_rev_styles%":"default","%pyre_fallback%":"","%pyre_main_top_padding%":"","%pyre_main_bottom_padding%":"","%pyre_hundredp_padding%":"","%pyre_show_first_featured_image%":"no","%pyre_display_header%":"yes","%pyre_header_100_width%":"default","%pyre_header_bg_color%":"","%pyre_header_bg_opacity%":"","%pyre_header_bg%":"","%pyre_header_bg_full%":"no","%pyre_header_bg_repeat%":"repeat","%pyre_displayed_menu%":"default","%pyre_display_footer%":"default","%pyre_display_copyright%":"default","%pyre_footer_100_width%":"default","%pyre_sidebar_position%":"default","%pyre_sidebar_bg_color%":"","%pyre_page_bg_layout%":"default","%pyre_page_bg_color%":"","%pyre_page_bg%":"","%pyre_page_bg_full%":"no","%pyre_page_bg_repeat%":"repeat","%pyre_wide_page_bg_color%":"","%pyre_wide_page_bg%":"","%pyre_wide_page_bg_full%":"no","%pyre_wide_page_bg_repeat%":"repeat","%pyre_page_title%":"default","%pyre_page_title_breadcrumbs_search_bar%":"default","%pyre_page_title_text%":"no","%pyre_page_title_text_alignment%":"default","%pyre_page_title_custom_text%":"","%pyre_page_title_text_size%":"","%pyre_page_title_custom_subheader%":"","%pyre_page_title_custom_subheader_text_size%":"","%pyre_page_title_font_color%":"","%pyre_page_title_100_width%":"default","%pyre_page_title_height%":"","%pyre_page_title_mobile_height%":"","%pyre_page_title_bar_bg_color%":"","%pyre_page_title_bar_borders_color%":"","%pyre_page_title_bar_bg%":"","%pyre_page_title_bar_bg_retina%":"","%pyre_page_title_bar_bg_full%":"default","%pyre_page_title_bg_parallax%":"default","%pyre_sidebar_sticky%":"default","%pyre_page_title_line_height%":"","%kd_featured-image-2_page_id%":"","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.69821","%_wpgmp_metabox_longitude%":"23.324880000000007","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%acf_bas_deptname%":"Training Center of BAS","%acf_bas_fax%":"+359 2 986 17 34","%acf_bas_email%":"<a href=\"mailto:tdc-phd@cu.bas.bg\">tdc-phd@cu.bas.bg</a>","%acf_bas_latitude%":"42.69821","%acf_bas_longtitude%":"23.324880000000007","%acf_bas_projects%":null,"%_acf_bas_projects%":"field_59d51129d9790","%_oembed_8a0cbcf235e25ad096c99e8f88f0c3f8%":"{{unknown}}","%_wpmf_gallery_custom_image_link%":"http://edu.bas.bg/","%_gallery_link_target%":"_blank","%_wpml_media_duplicate%":"1","%pyre_fallback_id%":"","%pyre_combined_header_bg_color%":"","%pyre_mobile_header_bg_color%":"","%pyre_header_bg_id%":"","%pyre_responsive_sidebar_order%":"","%pyre_page_bg_id%":"","%pyre_wide_page_bg_id%":"","%pyre_page_title_subheader_font_color%":"","%pyre_page_title_bar_bg_id%":"","%pyre_page_title_bar_bg_retina_id%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpml_word_count%":"{\"total\":431,\"to_translate\":{\"en\":431}}","%_wpml_media_featured%":"0","%_wpml_location_migration_done%":"1","%_thumbnail_id%":"17113","%_edit_lock%":"1563200559:18","%_edit_last%":"18","%pyre_demo_slider%":"","%_last_translation_edit_mode%":"native-editor","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"","%sbg_selected_sidebar_2%":"0","%sbg_selected_sidebar_2_replacement%":"","%_fusion%":{"slider_type":"no","slider":"0","revslider":"0","elasticslider":"0","show_first_featured_image":"yes","display_header":"yes","header_bg_full":"no","header_bg_repeat":"repeat","bg_full":"no","bg_repeat":"repeat","content_bg_full":"no","content_bg_repeat":"repeat","page_title_bar_text":"no","sbg_selected_sidebar":["0"],"pages_sidebar":"","sbg_selected_sidebar_2":["0"],"pages_sidebar_2":""},"%_alp_processed%":"1624443058","%avada_post_views_count%":"649","%avada_today_post_views_count%":"4","%avada_post_views_count_today_date%":"23-04-2024","%_acf_bas_deptname%":"field_59d4f547eeebe","%_acf_bas_address%":"field_59d4e5ef43eac","%_acf_bas_phone%":"field_59d4e64c43ead","%_acf_bas_fax%":"field_59d4e66443eae","%_acf_bas_email%":"field_59d4e69543eaf","%_acf_bas_site%":"field_59d4e6c743eb0","%_acf_bas_latitude%":"field_59d4f3b484674","%_acf_bas_longtitude%":"field_59d4f4b784675","taxonomy=translation_priority":"Optional"},"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"},"id":24593,"infowindow_disable":false,"categories":[{"icon":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","name":"Specialized Unit","id":"8","type":"category"}]}],"styles":[{"featureType":"poi","elementType":"all","stylers":[{"visibility":"off"}]}],"listing":{"listing_header":"Map Locations","display_search_form":true,"search_field_autosuggest":false,"display_category_filter":true,"display_sorting_filter":true,"display_radius_filter":false,"radius_dimension":"miles","apply_default_radius":false,"default_radius_dimension":"miles","display_location_per_page_filter":true,"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":false,"filters_position":"default","hide_map":false,"pagination":{"listing_per_page":"10"},"list_grid":"wpgmp_listing_list","listing_placeholder":"<div class=\"wpgmp_locations\">\r\n\t<div class=\"wpgmp_locations_head\">\r\n\t\t<div class=\"wpgmp_location_title\">\r\n\t\t\t<a href=\"{post_link}\" class=\"place_title\" data-zoom=\"{marker_zoom}\" data-marker=\"{marker_id}\">{marker_title}</a>\r\n\t\t</div>\r\n\t\t<div class=\"wpgmp_location_meta\">\r\n\t\t\t<span class=\"wpgmp_location_category fc-badge info\">{marker_category}</span>\r\n\t\t</div>\r\n\t</div>\r\n\t<div class=\"wpgmp_locations_foot\"></div>\r\n</div>","list_item_skin":{"name":"default","type":"item","sourcecode":"<div class=\"wpgmp_locations\">\r\n\t<div class=\"wpgmp_locations_head\">\r\n\t\t<div class=\"wpgmp_location_title\">\r\n\t\t\t<a href=\"{post_link}\" class=\"place_title\" data-zoom=\"{marker_zoom}\" data-marker=\"{marker_id}\">{marker_title}</a>\r\n\t\t</div>\r\n\t\t<div class=\"wpgmp_location_meta\">\r\n\t\t\t<span class=\"wpgmp_location_category fc-badge info\">{marker_category}</span>\r\n\t\t</div>\r\n\t</div>\r\n\t<div class=\"wpgmp_locations_foot\"></div>\r\n</div>\r\n"}},"map_property":{"map_id":"3","debug_mode":true},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"1":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","3":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","4":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","7":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","8":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png","9":"https://www.bas.bg/wp-content/plugins/wp-google-map-gold/assets/images/icons/google-map-default-icon.png"}}