Solkraftens skuggsida

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-170118"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="170118" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="U29sa3JhZnRlbnMgc2t1Z2dzaWRh" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci8xMy0xNy1zb2xrcmFmdGVucy1za3VnZ3NpZGEubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvMTMtMTctc29sa3JhZnRlbnMtc2t1Z2dzaWRhLm1wMw==">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/per-ask/">Per&nbsp;Ask</a> | 25 mars 2025<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsolkraftens-skuggsida%2F&amp;t=Solkraftens+skuggsida"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Solkraftens+skuggsida+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsolkraftens-skuggsida%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsolkraftens-skuggsida%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Solkraftens skuggsida&body=https://kvartal.se/artiklar/solkraftens-skuggsida/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/170118/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="kv-art-ext-sep"></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsolkraftens-skuggsida%2F&amp;t=Solkraftens+skuggsida"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Solkraftens+skuggsida+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsolkraftens-skuggsida%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsolkraftens-skuggsida%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Solkraftens skuggsida&body=https://kvartal.se/artiklar/solkraftens-skuggsida/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/170118/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/solkraftens-skuggsida/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 15 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/f1f6d824-87f2-4512-a379-3ae4f8b122dc"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-170118">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "170118"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">Under hösten har regeringen utifrån gediget faktaunderlag fastslagit att problemet med Sveriges elenergiproduktion är att vi har överskott av oplanerbar el samtidigt som industrin inte får nödvändig planerbar kraft.</p>
</div>
<div class="rest-of-article ">
<p>Det senare hindrar allvarligt utvecklingen av ny och befintlig industri.</p>
<h2>Solkraften svår att planera</h2>
<p>Det påpekas ofta att i den viktiga gröna omställningen som pågår har vi ett ökat behov av fossilfri el och att alla produktionsslag skulle behövas, så som vind och sol. Att avgöra vilken roll solkraften ska ha i vår energiförsörjning är brådskande eftersom ett stort antal ansökningar från bolag om nya stora solkraftsanläggningar, ofta på åkermark, ligger hos länsstyrelserna för godkännande. Solkraften har helt klart nackdelen att vara oplanerbar och ger el bara när solen lyser. I december och januari lyser den i medeltal en timme om dygnet. I juni och juli lyser den i snitt 8–9 timmar, och inte de timmar när behoven är som störst, men finns det andra förhållanden som väger upp detta?</p>
<p>Inget energislag är egentligen fossilfritt. Tillverkningen och installeringen av storskalig solkraft (typ 50MW) ger en växthusgasbelastning på 10–36 gCO2e/kWh (gram koldioxidekvivalenter per kilowattimme energi förutsatt en 30-årig livslängd).<sup>1</sup> Den högre siffran gäller när produktionen sker med kolkraft, vilket är fallet för största producenten Kina, och den lägre för lågfossil kraft. Detta ska jämföras med kärnkraft som ger 7, vindkraft 15 och kolkraft som ger 1100 gCO2e/kWh producerad el.</p>
<p>Så CO2-belastningen under tillverkningen måste kompenseras med låg CO2-belastning vid elproduktionen. Den senare bestäms bland annat av hur mycket solstrålning som finns i det geografiska området. I södra Sverige ligger styrkan i solinstrålningen på 1–3 medan många delar av världen ligger uppåt 6 enheter (vi talar om <em>irradians</em> – instrålningstäthet – med enheten kWh/m2). <em>The National Renewable Energy Laboratory</em> vid USA:s energidepartement har 2024 publicerat en omfattande rapport<sup>1</sup> där man bland annat beräknar tiden det tar att kompensera för CO2-belastningen vid produktion (<em>Carbon PayBack Time</em>, CPBT).</p>
<p>Denna varierar kraftigt med skillnaden i solstrålningen för olika geografiska lägen. I sydligare delar av USA kan CPBT vara 1–2 år beroende på hur CO2-belastande tillverkningen varit. Men i nordligare USA som Seattle kan CPBT rent av vara 16–20 år. Den långa tiden orsakas av det nordliga läget men framför allt av hur elförsörjningen och elnätet påverkas av att solkraften installeras. Bland annat är nätledningar till högeffekts-solanläggningar mycket resurskrävande.</p>
<p>Någon sådan här analys är vad jag vet inte gjord för Sverige, men borde utföras vid solkraftsinvesteringar. En sådan kalkyl är avgörande för om en solkraftssatsning ger någon minskning av koldioxidavtrycket. Med tanke på farhågorna om bristande lönsamhet bör det tas in att anläggningens livslängd kan bli kortare än den som antogs ursprungligen.</p>
<h2>Vindkraft ändå bättre än sol</h2>
<p>Idag debatteras livligt om Sverige ska bygga mer vindkraft med tanke på att den inte ger el kontinuerligt utan enbart när det blåser. Den är liksom solkraft ett intermittent kraftslag. Då är vindkraften i bättre läge än solkraften eftersom vinden blåser också under det mörka halvåret, men ingen av dem ger den behövliga planerbara elen. Svenska kraftnät har årsvis för sol och vind sammanställt kapacitetsfaktorer, det vill säga hur mycket elenergi som genereras i förhållande till den installerade kapaciteten. För 2011–2021 ligger vindkraft på 25–30 procent och solkraft på bara 5 procent men vid toppbelastning nära 0 procent.</p>
<p>Detta talar därför starkt för att storskalig solkraft måste kombineras med möjligheter att lagra energi.</p>
<p>Många för fram att batterilager är lösningen för solkraft, men hur realistiskt är detta? Den bästa batteritekniken idag är litiumbatterier. Tesla som är ledande batteritillverkare har containerstora enheter, MegaPack, som kan lagra 3,9 MWh el. En sådan enhet kostar 15 miljoner kronor.</p>
<p>Antag att solkraft ska stå för 10 procent av Sveriges elförsörjning och att vi med tanke på solens intermittens vill ha motsvarande 10 procent av sju dagar av Sveriges medelförbrukning lagrad i batterier, vilket är runt 240 000 MWh. Då behöver vi ha 62 000 MegaPack-enheter till en kostnad av hela 930 miljarder kronor, vilket är mer än hälften av Sveriges årliga budget!</p>
<p>Låt oss titta på en anläggning i Tägneby/Bjursby, som företaget GreenGo planerar utanför Linköping, för att få en mer konkret bild av begränsningarna hos batterilager. Denna ska kunna generera el med en effekt på 29 MW och motsvarande anläggning i Danmark uppskattas ge 36 GWh per år vilket kan motsvara årsförbrukningen för 1 800 villor. Men för att ha ström när solen inte lyser krävs batterilager. Och för att lagra el för 7 dagars förbrukning för dessa villor skulle vi behöva ha 180 Tesla MegaPack-containrar i Bjursby på 700 MWh till en kostnad av 2,8 miljarder kr!</p>
<p>Litiumbatterier innehåller, förutom litium, kobolt och nickel och dessa är svåra och energikrävande att bryta, och tillgången på kobolt är relativt knapp. Men den mesta av energin går åt i form av el som krävs i processen att tillverka batterierna. Koldioxidavtrycket är 61–200 kg CO2e/kWh, det vill säga per tillverkad kWh i batterikapacitet, beroende på om fossilsnål el eller kolproducerad el används.<sup>2</sup></p>
<p>Idag produceras hela 70 procent av världens batterier i Kina och då mestadels med kolel – varför jag väljer att uppskatta koldioxidavtrycket till 150 kg CO2e/kWh.</p>
<h2>Batterier ingen hållbar lösning</h2>
<p>De 62 000 MegaPack på 240 000 MWh som behövs ovan för 10 procent av elförsörjningen ger vid tillverkning en koldioxidbelastning 36 miljoner ton CO2e, vilken är jämförbar med Sveriges hela CO2e utsläpp 2023 som var på 44 miljoner ton. Att tillverka batterierna till 700 MWh för den lokala anläggningen i Bjursby ger en växthusgasbelastning på 120 000 ton CO2e. Denna mängd koldioxid motsvarar utsläppet från 55 000 bensin- eller dieselbilar som under ett år kör 1 500 mil. Så att lösa solkraftens intermittens med batterilager är varken hållbart ur ekonomisk eller miljömässig synpunkt.</p>
<p>Litiumbatterier är den batteriteknik som inom överskådlig tid finns tillgänglig för energilagring. Dessa batterier kom på 1970-talet för pacemakers och har under årtionden ständigt förbättrats. Tekniken kan nog ytterligare förfinas men inte radikalt. Andra batteritekniker kan komma fram men det tar tid. Vi bör också tänka på att det finns fysikaliska/fysiska begränsningar i batteriers förmåga att kemiskt lagra energi. Joner kan inte lagras hur tätt som helst på metallytor.</p>
<p>Kostnaden för litiumbatterierna har gått ned, men priset planar av då man börjar nå gränserna för möjliga förbättringar. Antal batterier är dessutom klart begränsade av tillgångar på till exempel kobolt och sällsynta jordartsmetaller, och det är olyckligt att det är Kina som nästan ensamma har kontroll över tillgångarna.</p>
<p>En annan lösning för att lagra energi är att använda två stora dammar med stor höjdskillnad och ha turbiner som ger ström när vatten släpps från den övre dammen. Sedan tar man vara på energi från till exempel solen genom att använda denna för att pumpa tillbaka vatten till den övre dammen. I schweiziska alperna har man byggt ett stort sådant pumplager med 400 meters höjdskillnad mellan dammarna på 20 000 MWh till en kostnad av 20 miljarder kronor. Byggnationen krävde gigantiska resurser med en byggtid på 14 år. En sådan anläggning går bara att bygga i ett alpliknande landskap som vi inte har i Sverige. Samtidigt skulle vi behöva ha 12 sådana anläggningar i Sverige för att kunna lagra 240 000 MWh enligt ovan.</p>
<h2>Fördelen med vattenkraft</h2>
<p>Sverige har fördelen att vattenkraft står för så stor del av vår elenergi och att vattenkraften är reglerbar kraft. Dess reglerande uppgift har ansträngts i och med att framför allt den intermittenta vindkraften har ökat (solkraften är ännu liten). Redan idag uppger Uniper, som äger många vattenkraftverk, att de tvingas reglera väl mycket och att i lägen där det blåser får de låta vatten spilla förbi turbinerna, det vill säga vattenel går förlorad. Det är därför tveksamt om vi kan förlita oss på vattenkraften för att balansera för utbyggd solkrafts intermittens. Den mesta av vattenkraften finns dessutom i norr, på långt avstånd från den huvudsakliga förbrukningen i söder. Vi har redan klara problem med att kraftledningarnas överföringskapacitet från norr till söder är för låg, vilket är ytterligare ett hinder i att vattenkraften ska kompensera för solens intermittens.</p>
<p>Som konsekvens av att bidraget från sol- och vindkraft ökat har Svenska kraftnäts balanseringskostnader, det vill säga kostnaden för att betala för att producenter drar ner eller ökar sin produktion, ökat från 1 miljard kronor 2014 till hela 8 miljarder kronor 2021. Och då är solkraften idag liten, men hur kommer kostnaden att se ut om solelens andel stiger till exempelvis 10 procent?</p>
<p>Solkraftsföretag för ibland fram att avancerad styrelektronik och AI ska lösa problemen med solkraftens intermittens. I ett elsystem måste i varje bråkdel av en sekund producerad och förbrukad el vara lika. Här har elektroniska system en roll men de kan aldrig trolla fram elenergi som inte finns på grund av obalansen.</p>
<h2>Solel åt hela jorden?</h2>
<p>Det finns dock publikationer som pekar åt ett annat håll. I en artikel i <em>Nature</em> från 2023<sup>3</sup> görs simuleringar med en makroskopisk ekonomi och innovationsmodell där man kommer fram till att inom något eller några årtionden kommer jordens elförsörjning att domineras av solel.</p>
<p>Resultaten bygger på att priserna på solpaneler och lagringsbatterier har gått ned under ett antal år och att denna exponentiella nedgång kommer att fortsätta. En sådan modell kan fungera för mycket stora makrosystem, men för solelssystemet är modellen bristfällig eftersom utveckling här påverkas så mycket av att enskilda innovationer/innovationssprång sker eller inte sker. Modellen tar inte heller med de begränsningar som finns i tillgång på framför allt metalliska råvaror. Den beaktar inte heller den mycket stora mängd energi och växthusgasutsläpp som tillverkningen kräver. Artikeln berör också bara marginellt det ofantliga behovet av att buffra solenergi med lagring men förutsätter att innovationssystemet löser detta genom att batterier i exponentiell takt ska kunna lagra mer och mer energi framöver.</p>
<p>Det är här som resonemanget har brister. Författarna verkar inte ha kunskap i de tekniker som solkraftsutvecklingen bygger på och tycks då sakna möjligheter att bedöma validiteten i sin modellering. Resultaten ligger nu långt från tekniska realiteter. Artikeln har allvarliga brister i vetenskaplig kvalitet och vi kan fråga oss om den ens borde publicerats i <em>Nature</em>?</p>
<p>Vid låg andel solel, kanske 1 procent, så kan det svenska elsystemet balansera ryckigheten som solkraften ger eftersom detta domineras av vatten- och kärnkraft. Men vid högre andelar solel fås allvarliga störningar i elsystemet.</p>
<h2>Lärdomen från Tyskland</h2>
<p>Ser vi i ett internationellt perspektiv har Tyskland i snabb takt byggt ut sin solkraft så att den idag är 12 procent av totalen, vilket skapar stora svårigheter med obalans. I en artikel av <em>SEB Research</em> i Tyskland<sup>4</sup> är slutsatsen att solkraft förstör för sig själv genom att öka utbudet av kraft när behovet är lågt, vilket leder till mycket låga priser. Vid starkt solsken måste producenten rent av betala 80 öre/kWh för att bli av med elen och för att elsystemet inte ska kollapsa.</p>
<blockquote><p>I Danmark har man också snabbt byggt ut solkraft och då fått problem med obalans i elnätet.</p></blockquote>
<p>I december 2024 har vi nu sett att obalansen i det tyska elsystemet på grund av för stor andel oplanerbar el gett mycket höga elpriser när sol och vind uteblir. Dessa höga elpriser slår då igenom i södra Sverige, till stor del på grund av att Sverige har stängt kärnkraften i södra Sverige.</p>
<p>Det problematiska tillståndet för ett elsystem med stor andel sol och vind, i lägen när inte solen lyser och det är stiltje, har efter hand fått den internationella benämningen ”<em>Dunkelflaute</em>”, mörk stiltje. Vi måste i Sverige akta oss för att hamna i Tysklands situation där de har en industrikris kopplad till den brist på planerbar energi som uppstått efter att Tyskland lade ner sin kärnkraft.</p>
<p>I Danmark har man också snabbt byggt ut solkraft och då fått problem med obalans i elnätet. I april 2023 var man vid ett tillfälle tvungen att betala 25 SEK/kWh för att bli av med elöverskottet.</p>
<p>Också Polen har snabbt ökat på sin solkraft och vid 22 tillfällen 2023 varit tvunget att koppla från solkraft för att undvika kollaps. Kalifornien har också problem med sin solkraftsel och har i detta högteknologiska samhälle anmärkningsvärt nog måst bryta elförsörjningen växelvis till olika geografiska områden när solen inte lyser.</p>
<h2>Stor ökning av solkraft</h2>
<p>Men i Sverige är det väl inte så illa? Nej, men snart om vi fortsätter på den inslagna linjen. Solkraften står idag för 1,9 procent av installerad kraft och ökar exponentiellt med 60 procent per år, varför vi snart riskerar att komma upp i Tysklands nivå. Enligt uppgift är det ansökningar om solkraftsansläggningar på 20 TWh som ligger hos länsstyrelserna för bedömning. Om dessa beviljas skulle Sveriges solkraft i energimixen gå upp till 12 procent, vilket skulle ge problem liknande Tysklands.</p>
<p>Det finns ett antal bolag verksamma i Sverige som kontaktar ägare av åkermark med erbjudanden om generösa arrendeavtal under 30–40 år mot att man får bygga en solkraftsanläggning och skönmålar möjligheterna med solkraften. De ger en falskt positiv bild av solkraften och dess roll i en grön omställning och hävdar rent av felaktigt att den skulle lösa obalans mellan södra och norra Sverige.</p>
<p>Bolagen hoppas sedan att en konsult levererar en fördelaktig elprisprognos för framtiden, så att man med god vinst kan sälja projektet vidare till vanligen ett större internationellt bolag som ska bygga och driva det hela. Och går det dåligt är det ett separat bolag som kan sättas i konkurs, varvid de ekonomiska åtagandena försvinner.</p>
<p>Det påstås ibland att solkraften är en möjlighet att förbättra jordbrukarnas ekonomi, men denna är teoretisk och förutsätter att solkraftsbolagen får bra betalt för den genererade elen så att de under 30–40 år ska kunna betala höga arrenden till markägarna. Om stor mängd solkraft kommer i drift fås en överproduktion av el vid de tillfällen då solen lyser, vilket leder till att priset på elen under dessa stunder förväntas bli mycket lågt och företaget blir olönsamt med hög sannolikhet för konkurs. Jordbrukaren står då utan intäkter, och det hade varit mycket bättre att använda jordbruksmarken för just jordbruk.</p>
<p>Farhågorna kring den dåliga lönsamheten stärks av den utredning som forskaren <strong>Christian Sandström</strong> och ekonomen <strong>Christian Steinbeck</strong> gjort kring vindkraftsbolagens bristande lönsamhet och som är publicerad i Kvartal.<sup>5</sup> Samtidigt är solkraften i ett väsentligt sämre läge än vindkraften, eftersom den senare ger el under det mörka halvåret då solkraftens bidrag är mycket lågt. Så solkraftens lönsamhetsproblem borde rimligen vara större. Ett tecken på lönsamhetsproblem är att ett solkraftsbolag i Linköping nyligen gått i konkurs, och det finns andra exempel.</p>
<h2>Livsmedelsindustrin och livsmedelsförsörjningen missgynnas</h2>
<p>Konsekvensen av solkraftssatsningar är att fin åkermark inte längre bidrar till vår livsmedelsproduktion, vilket får ekonomiska konsekvenser. Livsmedelsindustrin missgynnas, och detta är olyckligt från beredskapssynpunkt. Det är också stora natur- och kulturvärden som förstörs. Vår självförsörjningsgrad för livsmedel har redan minskat från 75 procent 1988 till 50 procent idag, och det vore olyckligt om den minskar ytterligare. I dagens osäkra världspolitiska läge bör Sverige i stället av beredskapsskäl öka sin försörjningsgrad av livsmedel. I Finland är motsvarande siffra 80 procent.</p>
<p>Det är för närvarande ett stort tryck på länsstyrelserna att ta ställning till ansökningar om solkraftsanläggningar. Bolagen beskriver med hjälp av konsulter projektens fina bidrag till den gröna omställningen.</p>
<p>Länsstyrelserna bör därför betänka sitt stora ansvar vid besluten. Det har att väga den tveksamma nyttan av solkraft mot att jordbruksmark tas i anspråk samt att fina naturvärden och kulturmiljöer skadas.</p>
<p>Av politiska skäl har delar av vår kärnkraft lagts ned, vilket allvarligt skadat vårt föredömliga energisystem och gett en mycket stor kapitalförstörelse. Att kompensera för denna förlust är svårt och tar tyvärr lång tid. Storskalig solkraft är varken miljömässigt eller ekonomiskt en del av lösningen.</p>
<p>Ny kärnkraft ger den behövliga planerbara elenergin för industri och hushåll, är miljövänlig och ger låga CO2e utsläpp. Men att bygga kärnkraft tar tid. Under tiden behöver vi mer elenergi i södra Sverige.</p>
<p>Innan kärnkraften hunnit byggas ut får vi nog bita i det sura äpplet och under en övergångsperiod överväga att använda eller bygga gaskraftverk eller annan fossil kraft. Miljöeffekterna i form av CO2-utsläppen från dessa under övergångsperioden är mindre än de alternativ som står till buds.</p>
<p>Så här kan man summera resonemangen:</p>
<ul>
<li>Storskalig solkraft ansluten till elnätet ger inte den planerbara el som industri och hushåll behöver varje dag vilket är ekonomiskt ohållbart.</li>
<li>Solanläggningar som produceras ger en miljöbelastning/CO2-utsläpp som är påtaglig redan vid tänkt användning under många år och blir ohållbar miljömässigt om anläggningarna tvingas stängas i förtid av ekonomiska skäl.</li>
<li>Att solkraften bara ger el de stunder solen lyser skulle kunna avhjälpas genom att lagra elen i batterier. Kostnaden för dessa blir dock ohållbart stor och de skulle ge en ofantligt stor miljöbelastning.</li>
<li>Storskaliga solkraftsanläggningar tar jordbruksmark i anspråk som annars skulle användas för livsmedelsproduktion. Landets livsmedelsförsörjning i ett krisläge drabbas också. Dessa stora anläggningar förstör dessutom de vackra jordbrukslandskapen och skadar fina naturvärden.</li>
<li>På kort sikt bör länsstyrelserna omgående säga nej till nya storskaliga solkraftsanläggningar.</li>
<li>I regeringens energiplanering bör storskalig solkraft uteslutas som ett kraftslag för Sveriges energiförsörjning.</li>
<li>På lång sikt kan förutsättningarna för att använda storskalig solkraft förbättras. Men utvecklingen här är svår att förutse och kan inte intecknas idag. Det räcker inte med idéer, utan det krävs tekniker som är mogna att kunna produceras och detta till en kostnad som är försvarbar.</li>
</ul>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="170118">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<ol>
<li>Brittany L Smith, Ashok Sekar, Heather Mirletz, Garvin Heath och Robert Margolis, <em>An updated life cycle assessment of utility-scale solar photovoltaic systems installed in the United States </em>(National Renewable Energy Laboratory 2024) <a href="https://www.nrel.gov/docs/fy24osti/87372.pdf">https://www.nrel.gov/docs/fy24osti/87372.pdf</a></li>
<li>Erik Emilsson och Lisbeth Dahllöf, <em>Lithium-ion vehicle battery production: Status 2019 on energy use, CO2 emissions, use of metals, products environmental footprint, and recycling</em> (IVL Swedish Environmental Research Institute and the Swedish Energy Agency, Report C444, November 2019)</li>
<li>Femke J M M Nijsse, Jean-Francois Mercure, Nadia Ameli, Francesca Larosa, Sumit Kothari, Jamie Rickman, Pim Vercoulen och Hector Pollitt, <em>The momentum of the solar energy transition</em> (Nature Communications 14:6542 2023)<br />
<a href="https://doi.org/10.1038/s41467-023-41971-7">https://doi.org/10.1038/s41467-023-41971-7</a></li>
<li>Bjarne Schieldrop, <em>The self-destructive force of unregulated solar power</em> (SEB Research 21 maj 2024)<br />
<a href="https://research.sebgroup.com/macro-ficc/reports/42287">https://research.sebgroup.com/macro-ficc/reports/42287</a></li>
<li>Sandström C och Steinbeck C, <a href="https://kvartal.se/artiklar/pengarna-borta-med-vinden/"><em>Pengarna borta med vinden</em></a> (Kvartal 28 februari 2024)</li>
</ol>
</div>
</div>
<div class="author-byline">Per Ask är civilingenjör i teknisk fysik och elektroteknik, teknologie doktor och sedan 1989 professor i medicinsk teknik och nu emeritus vid Linköpings universitet. Han har kunskap i elektroniska system och batteriteknik samt har undervisat om sjukhusens elkraftssystem.
</div>
</div>
