Protein Molekylvægt Beregner

Introduktion

Protein molekylvægt beregneren er et essentielt værktøj for biokemikere, molekylære biologer og proteinspecialister, der har brug for at bestemme massen af proteiner baseret på deres aminosyresekvenser. Proteiner er komplekse makromolekyler sammensat af aminosyrekæder, og at kende deres molekylvægt er afgørende for forskellige laboratorieteknikker, eksperimentelt design og dataanalyse. Denne beregner giver en hurtig og præcis måde at estimere molekylvægten af ethvert protein ved hjælp af dets aminosyresekvens, hvilket sparer forskere værdifuld tid og reducerer potentialet for beregningsfejl.

Protein molekylvægt, ofte udtrykt i Daltons (Da) eller kilodaltons (kDa), repræsenterer summen af de individuelle vægte af alle aminosyrer i proteinet, idet der tages højde for vandmolekylerne, der går tabt under dannelsen af peptidbindinger. Denne grundlæggende egenskab påvirker proteinadfærd i opløsning, elektroforese mobilitet, krystallisationsegenskaber og mange andre fysiske og kemiske karakteristika, der er vigtige i forskning og industrielle anvendelser.

Vores brugervenlige beregner kræver kun den en-bogstavs aminosyresekvens af dit protein for at generere præcise molekylvægtestimater, hvilket gør det tilgængeligt for både erfarne forskere og studerende, der er nye inden for proteinvidenskab.

Hvordan Protein Molekylvægt Beregnes

Den Grundlæggende Formel

Molekylvægten af et protein beregnes ved hjælp af følgende formel:

$MW_{protein} = \sum_{i=1}^{n} MW_{amino acid_i} - (n-1) \times MW_{water} + MW_{water}$

Hvor:

• $MW_{protein}$ er molekylvægten af hele proteinet i Daltons (Da)
• $\sum_{i=1}^{n} MW_{amino acid_i}$ er summen af molekylvægtene af alle individuelle aminosyrer
• $n$ er antallet af aminosyrer i sekvensen
• $MW_{water}$ er molekylvægten af vand (18.01528 Da)
• $(n-1)$ repræsenterer antallet af peptidbindinger, der dannes
• Den sidste $+ MW_{water}$ term tager højde for terminalgrupperne (H og OH)

Aminosyre Molekylvægte

Beregningen bruger de standard molekylvægte af de 20 almindelige aminosyrer:

Vandtab ved Dannelsen af Peptidbindinger

Når aminosyrer går sammen for at danne et protein, skaber de peptidbindinger. Under denne proces frigives et vandmolekyle (H₂O) for hver binding, der dannes. Dette vandtab skal tages højde for i beregningen af molekylvægten.

For et protein med n aminosyrer er der (n-1) peptidbindinger, der dannes, hvilket resulterer i tabet af (n-1) vandmolekyler. Imidlertid tilføjer vi et vandmolekyle tilbage for at tage højde for terminalgrupperne (H ved N-terminalen og OH ved C-terminalen).

Eksempelberegning

Lad os beregne molekylvægten af et simpelt tripeptid: Ala-Gly-Ser (AGS)

1. Summér vægtene af individuelle aminosyrer:

   • Alanin (A): 71.03711 Da
   • Glycin (G): 57.02146 Da
   • Serin (S): 87.03203 Da
   • Total: 215.0906 Da

2. Træk vandtab fra peptidbindinger:

   • Antal peptidbindinger = 3-1 = 2
   • Vandmolekylvægt = 18.01528 Da
   • Total vandtab = 2 × 18.01528 = 36.03056 Da

3. Tilføj et vandmolekyle tilbage for terminalgrupper:

   • 18.01528 Da

4. Endelig molekylvægt:

   • 215.0906 - 36.03056 + 18.01528 = 197.07532 Da

Sådan Bruger Du Denne Beregner

At bruge Protein Molekylvægt Beregneren er ligetil:

1. Indtast din proteinsekvens i tekstboksen ved hjælp af de standard en-bogstavs aminosyrekoder (A, R, N, D, C, E, Q, G, H, I, L, K, M, F, P, S, T, W, Y, V).

2. Beregneren vil automatisk validere din indtastning for at sikre, at den kun indeholder gyldige aminosyre koder.

3. Klik på "Beregn Molekylvægt" knappen eller vent på, at den automatiske beregning afsluttes.

4. Se resultaterne, som inkluderer:

   • Den beregnede molekylvægt i Daltons (Da)
   • Sekvenslængden (antal aminosyrer)
   • En opdeling af aminosyrekomposition
   • Den anvendte formel til beregning

5. Du kan kopiere resultaterne til din udklipsholder ved at klikke på "Kopier" knappen til brug i rapporter eller yderligere analyse.

Indtastningsretningslinjer

For nøjagtige resultater, følg disse retningslinjer, når du indtaster din proteinsekvens:

• Brug kun de standard en-bogstavs aminosyre koder (store eller små bogstaver)
• Inkluder ikke mellemrum, tal eller specialtegn
• Fjern eventuelle ikke-aminosyrerelaterede tegn (såsom sekvensnummerering)
• For sekvenser med ikke-standard aminosyrer, overvej at bruge alternative værktøjer, der understøtter udvidede aminosyrekoder

Fortolkning af Resultaterne

Beregneren giver flere oplysninger:

1. Molekylvægt: Den estimerede molekylvægt af dit protein i Daltons (Da). For større proteiner kan dette udtrykkes i kilodaltons (kDa).

2. Sekvenslængde: Det samlede antal aminosyrer i din sekvens.

3. Aminosyrekomposition: En visuel opdeling af aminosyreindholdet i dit protein, der viser både tællingen og procentdelen af hver aminosyre.

4. Beregningmetode: En klar forklaring af, hvordan molekylvægten blev beregnet, herunder den anvendte formel.

Anvendelsesområder

Protein Molekylvægt Beregneren har mange anvendelser på tværs af forskellige områder inden for livsvidenskab:

Proteinrensning og Analyse

Forskere bruger molekylvægtinformation til at:

• Opsætte passende gelfiltreringskolonner
• Bestemme passende polyacrylamidgelkoncentrationer til SDS-PAGE
• Tolkning af massespektrometridata
• Validere proteinudtryk og rensningsresultater

Rekombinant Proteinproduktion

Bioteknologiske virksomheder er afhængige af nøjagtige molekylvægtberegninger til at:

• Designe ekspressionskonstruktioner
• Estimere proteinudbytter
• Udvikle rensningsstrategier
• Karakterisere endelige produkter

Peptidsyntese

Peptidkemikere bruger molekylvægtberegninger til at:

• Bestemme mængden af startmaterialer, der er nødvendige
• Beregne teoretiske udbytter
• Bekræfte identiteten af syntetiserede peptider
• Designe analytiske metoder til kvalitetskontrol

Strukturbiologi

Strukturbiologer har brug for molekylvægtinformation til at:

• Opsætte krystallisationstrials
• Tolkning af røntgendiffraktionsdata
• Analysere protein komplekser
• Beregne stoikiometri af protein-protein interaktioner

Farmaceutisk Udvikling

Lægemiddeludviklere bruger proteinmolekylvægt til at:

• Karakterisere terapeutiske proteiner
• Udvikle formuleringsstrategier
• Designe analytiske metoder
• Etablere specifikationer for kvalitetskontrol

Akademisk Forskning

Studerende og forskere bruger beregneren til:

• Laboratorieforsøg
• Dataanalyse
• Eksperimentelt design
• Uddannelsesmæssige formål

Alternativer

Mens vores Protein Molekylvægt Beregner giver hurtige og nøjagtige estimater, er der alternative metoder til at bestemme proteinmolekylvægt:

1. Eksperimentelle Metoder:

   • Massespektrometri (MS): Giver meget præcise målinger af molekylvægt og kan opdage post-translational modificeringer
   • Størrelsesudskillelseschromatografi (SEC): Estimerer molekylvægt baseret på hydrodynamisk radius
   • SDS-PAGE: Giver en omtrentlig molekylvægt baseret på elektroforetisk mobilitet

2. Andre Beregningsværktøjer:

   • ExPASy ProtParam: Tilbyder yderligere proteinparametre ud over molekylvægt
   • EMBOSS Pepstats: Giver detaljeret statistisk analyse af proteinsekvenser
   • Protein Calculator v3.4: Inkluderer yderligere beregninger som isoelektrisk punkt og ekstinktionskoefficient

3. Specialiseret Software:

   • For proteiner med ikke-standard aminosyrer eller post-translational modificeringer
   • For komplekse proteinassemblager eller multimeriske proteiner
   • For isotopisk mærkede proteiner brugt i NMR-studier

Historie om Bestemmelse af Protein Molekylvægt

Begrebet molekylvægt har været fundamentalt for kemi siden John Dalton foreslog sin atomteori i det tidlige 19. århundrede. Dog har anvendelsen til proteiner en mere nylig historie:

Tidlig Proteinvidenskab (1800'erne-1920'erne)

• I 1838 myntede Jöns Jacob Berzelius termen "protein" fra det græske ord "proteios," som betyder "primær" eller "af første vigtighed."
• Tidlige proteinspecialister som Frederick Sanger begyndte at forstå, at proteiner var sammensat af aminosyrer.
• Begrebet proteiner som makromolekyler med definerede molekylvægte opstod gradvist.

Udvikling af Analytiske Teknikker (1930'erne-1960'erne)

• Opfindelsen af ultracentrifugering af Theodor Svedberg i 1920'erne tillod de første nøjagtige målinger af proteinmolekylvægte.
• Udviklingen af elektroforese teknikker i 1930'erne af Arne Tiselius gav en anden metode til at estimere proteinstørrelse.
• I 1958 afsluttede Stanford Moore og William H. Stein den første fulde aminosyresekvens af ribonuklease, hvilket gjorde præcise beregninger af molekylvægt muligt.

Moderne Tidsalder (1970'erne-Nu)

• Udviklingen af massespektrometri teknikker revolutionerede bestemmelsen af proteinmolekylvægt.
• John Fenn og Koichi Tanaka modtog Nobelprisen i kemi i 2002 for deres udvikling af bløde desorptionsioniseringsmetoder til massespektrometriske analyser af biologiske makromolekyler.
• Beregningsmetoder til at forudsige protein egenskaber, herunder molekylvægt, blev stadig mere sofistikerede og tilgængelige.
• Fremkomsten af genomik og proteomik i 1990'erne og 2000'erne skabte et behov for højt gennemstrømnings proteinanalyseværktøjer, herunder automatiserede molekylvægtberegnere.

I dag er beregning af proteinmolekylvægt en rutinemæssig, men essentiel del af proteinvidenskab, faciliteret af værktøjer som vores beregner, der gør disse beregninger tilgængelige for forskere verden over.

Kodeeksempler

Her er eksempler på, hvordan man beregner proteinmolekylvægt i forskellige programmeringssprog:

1' Excel VBA Funktion til Beregning af Protein Molekylvægt
2Function ProteinMolecularWeight(sequence As String) As Double
3    ' Aminosyre molekylvægte
4    Dim aaWeights As Object
5    Set aaWeights = CreateObject("Scripting.Dictionary")
6    
7    ' Initialiser aminosyre vægte
8    aaWeights("A") = 71.03711
9    aaWeights("R") = 156.10111
10    aaWeights("N") = 114.04293
11    aaWeights("D") = 115.02694
12    aaWeights("C") = 103.00919
13    aaWeights("E") = 129.04259
14    aaWeights("Q") = 128.05858
15    aaWeights("G") = 57.02146
16    aaWeights("H") = 137.05891
17    aaWeights("I") = 113.08406
18    aaWeights("L") = 113.08406
19    aaWeights("K") = 128.09496
20    aaWeights("M") = 131.04049
21    aaWeights("F") = 147.06841
22    aaWeights("P") = 97.05276
23    aaWeights("S") = 87.03203
24    aaWeights("T") = 101.04768
25    aaWeights("W") = 186.07931
26    aaWeights("Y") = 163.06333
27    aaWeights("V") = 99.06841
28    
29    ' Vand molekylvægt
30    Const WATER_WEIGHT As Double = 18.01528
31    
32    ' Konverter sekvens til store bogstaver
33    sequence = UCase(sequence)
34    
35    ' Beregn total vægt
36    Dim totalWeight As Double
37    totalWeight = 0
38    
39    ' Summér individuelle aminosyre vægte
40    Dim i As Integer
41    For i = 1 To Len(sequence)
42        Dim aa As String
43        aa = Mid(sequence, i, 1)
44        
45        If aaWeights.Exists(aa) Then
46            totalWeight = totalWeight + aaWeights(aa)
47        Else
48            ' Ugyldig aminosyre kode
49            ProteinMolecularWeight = -1
50            Exit Function
51        End If
52    Next i
53    
54    ' Træk vandtab fra peptidbindinger og tilføj terminal vand
55    Dim numAminoAcids As Integer
56    numAminoAcids = Len(sequence)
57    
58    ProteinMolecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT
59End Function
60
61' Brug i Excel:
62' =ProteinMolecularWeight("ACDEFGHIKLMNPQRSTVWY")
63

1def calculate_protein_molecular_weight(sequence):
2    """
3    Beregn molekylvægten af et protein ud fra dets aminosyresekvens.
4    
5    Args:
6        sequence (str): Proteinsekvens ved hjælp af en-bogstavs aminosyrekoder
7        
8    Returns:
9        float: Molekylvægt i Daltons (Da)
10    """
11    # Aminosyre molekylvægte
12    aa_weights = {
13        'A': 71.03711,
14        'R': 156.10111,
15        'N': 114.04293,
16        'D': 115.02694,
17        'C': 103.00919,
18        'E': 129.04259,
19        'Q': 128.05858,
20        'G': 57.02146,
21        'H': 137.05891,
22        'I': 113.08406,
23        'L': 113.08406,
24        'K': 128.09496,
25        'M': 131.04049,
26        'F': 147.06841,
27        'P': 97.05276,
28        'S': 87.03203,
29        'T': 101.04768,
30        'W': 186.07931,
31        'Y': 163.06333,
32        'V': 99.06841
33    }
34    
35    # Vand molekylvægt
36    WATER_WEIGHT = 18.01528
37    
38    # Konverter sekvens til store bogstaver
39    sequence = sequence.upper()
40    
41    # Valider sekvens
42    for aa in sequence:
43        if aa not in aa_weights:
44            raise ValueError(f"Ugyldig aminosyre kode: {aa}")
45    
46    # Summér individuelle aminosyre vægte
47    total_weight = sum(aa_weights[aa] for aa in sequence)
48    
49    # Træk vandtab fra peptidbindinger og tilføj terminal vand
50    num_amino_acids = len(sequence)
51    molecular_weight = total_weight - (num_amino_acids - 1) * WATER_WEIGHT + WATER_WEIGHT
52    
53    return molecular_weight
54
55# Eksempel på brug:
56sequence = "MVKMDVYKGSSIGDSMSRSM"
57mw = calculate_protein_molecular_weight(sequence)
58print(f"Molekylvægt: {mw:.2f} Da")
59

1function calculateProteinMolecularWeight(sequence) {
2  // Aminosyre molekylvægte
3  const aaWeights = {
4    'A': 71.03711,
5    'R': 156.10111,
6    'N': 114.04293,
7    'D': 115.02694,
8    'C': 103.00919,
9    'E': 129.04259,
10    'Q': 128.05858,
11    'G': 57.02146,
12    'H': 137.05891,
13    'I': 113.08406,
14    'L': 113.08406,
15    'K': 128.09496,
16    'M': 131.04049,
17    'F': 147.06841,
18    'P': 97.05276,
19    'S': 87.03203,
20    'T': 101.04768,
21    'W': 186.07931,
22    'Y': 163.06333,
23    'V': 99.06841
24  };
25  
26  // Vand molekylvægt
27  const WATER_WEIGHT = 18.01528;
28  
29  // Konverter sekvens til store bogstaver
30  sequence = sequence.toUpperCase();
31  
32  // Valider sekvens
33  for (let i = 0; i < sequence.length; i++) {
34    const aa = sequence[i];
35    if (!aaWeights[aa]) {
36      throw new Error(`Ugyldig aminosyre kode: ${aa}`);
37    }
38  }
39  
40  // Summér individuelle aminosyre vægte
41  let totalWeight = 0;
42  for (let i = 0; i < sequence.length; i++) {
43    totalWeight += aaWeights[sequence[i]];
44  }
45  
46  // Træk vandtab fra peptidbindinger og tilføj terminal vand
47  const numAminoAcids = sequence.length;
48  const molecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT;
49  
50  return molecularWeight;
51}
52
53// Eksempel på brug:
54const sequence = "ACDEFGHIKLMNPQRSTVWY";
55try {
56  const mw = calculateProteinMolecularWeight(sequence);
57  console.log(`Molekylvægt: ${mw.toFixed(2)} Da`);
58} catch (error) {
59  console.error(error.message);
60}
61

1import java.util.HashMap;
2import java.util.Map;
3
4public class ProteinMolecularWeightCalculator {
5    private static final Map<Character, Double> aminoAcidWeights = new HashMap<>();
6    private static final double WATER_WEIGHT = 18.01528;
7    
8    static {
9        // Initialiser aminosyre vægte
10        aminoAcidWeights.put('A', 71.03711);
11        aminoAcidWeights.put('R', 156.10111);
12        aminoAcidWeights.put('N', 114.04293);
13        aminoAcidWeights.put('D', 115.02694);
14        aminoAcidWeights.put('C', 103.00919);
15        aminoAcidWeights.put('E', 129.04259);
16        aminoAcidWeights.put('Q', 128.05858);
17        aminoAcidWeights.put('G', 57.02146);
18        aminoAcidWeights.put('H', 137.05891);
19        aminoAcidWeights.put('I', 113.08406);
20        aminoAcidWeights.put('L', 113.08406);
21        aminoAcidWeights.put('K', 128.09496);
22        aminoAcidWeights.put('M', 131.04049);
23        aminoAcidWeights.put('F', 147.06841);
24        aminoAcidWeights.put('P', 97.05276);
25        aminoAcidWeights.put('S', 87.03203);
26        aminoAcidWeights.put('T', 101.04768);
27        aminoAcidWeights.put('W', 186.07931);
28        aminoAcidWeights.put('Y', 163.06333);
29        aminoAcidWeights.put('V', 99.06841);
30    }
31    
32    public static double calculateMolecularWeight(String sequence) throws IllegalArgumentException {
33        // Konverter sekvens til store bogstaver
34        sequence = sequence.toUpperCase();
35        
36        // Valider sekvens
37        for (int i = 0; i < sequence.length(); i++) {
38            char aa = sequence.charAt(i);
39            if (!aminoAcidWeights.containsKey(aa)) {
40                throw new IllegalArgumentException("Ugyldig aminosyre kode: " + aa);
41            }
42        }
43        
44        // Summér individuelle aminosyre vægte
45        double totalWeight = 0;
46        for (int i = 0; i < sequence.length(); i++) {
47            totalWeight += aminoAcidWeights.get(sequence.charAt(i));
48        }
49        
50        // Træk vandtab fra peptidbindinger og tilføj terminal vand
51        int numAminoAcids = sequence.length();
52        double molecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT;
53        
54        return molecularWeight;
55    }
56    
57    public static void main(String[] args) {
58        try {
59            String sequence = "MVKMDVYKGSSIGDSMSRSM";
60            double mw = calculateMolecularWeight(sequence);
61            System.out.printf("Molekylvægt: %.2f Da%n", mw);
62        } catch (IllegalArgumentException e) {
63            System.err.println(e.getMessage());
64        }
65    }
66}
67

1#include <iostream>
2#include <string>
3#include <map>
4#include <stdexcept>
5#include <algorithm>
6
7double calculateProteinMolecularWeight(const std::string& sequence) {
8    // Aminosyre molekylvægte
9    std::map<char, double> aaWeights = {
10        {'A', 71.03711},
11        {'R', 156.10111},
12        {'N', 114.04293},
13        {'D', 115.02694},
14        {'C', 103.00919},
15        {'E', 129.04259},
16        {'Q', 128.05858},
17        {'G', 57.02146},
18        {'H', 137.05891},
19        {'I', 113.08406},
20        {'L', 113.08406},
21        {'K', 128.09496},
22        {'M', 131.04049},
23        {'F', 147.06841},
24        {'P', 97.05276},
25        {'S', 87.03203},
26        {'T', 101.04768},
27        {'W', 186.07931},
28        {'Y', 163.06333},
29        {'V', 99.06841}
30    };
31    
32    // Vand molekylvægt
33    const double WATER_WEIGHT = 18.01528;
34    
35    // Konverter sekvens til store bogstaver
36    std::string upperSequence = sequence;
37    std::transform(upperSequence.begin(), upperSequence.end(), upperSequence.begin(), ::toupper);
38    
39    // Valider sekvens
40    for (char aa : upperSequence) {
41        if (aaWeights.find(aa) == aaWeights.end()) {
42            throw std::invalid_argument(std::string("Ugyldig aminosyre kode: ") + aa);
43        }
44    }
45    
46    // Summér individuelle aminosyre vægte
47    double totalWeight = 0.0;
48    for (char aa : upperSequence) {
49        totalWeight += aaWeights[aa];
50    }
51    
52    // Træk vandtab fra peptidbindinger og tilføj terminal vand
53    int numAminoAcids = upperSequence.length();
54    double molecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT;
55    
56    return molecularWeight;
57}
58
59int main() {
60    try {
61        std::string sequence = "ACDEFGHIKLMNPQRSTVWY";
62        double mw = calculateProteinMolecularWeight(sequence);
63        std::cout << "Molekylvægt: " << std::fixed << std::setprecision(2) << mw << " Da" << std::endl;
64    } catch (const std::exception& e) {
65        std::cerr << "Fejl: " << e.what() << std::endl;
66    }
67    
68    return 0;
69}
70

Ofte Stillede Spørgsmål

Hvad er protein molekylvægt?

Protein molekylvægt, også kaldet molekylmasse, er den samlede masse af et proteinmolekyle udtrykt i Daltons (Da) eller kilodaltons (kDa). Det repræsenterer summen af masserne af alle atomer i proteinet, idet der tages højde for tabet af vandmolekyler under dannelsen af peptidbindinger. Denne grundlæggende egenskab er afgørende for protein karakterisering, rensning og analyse.

Hvor nøjagtig er denne protein molekylvægt beregner?

Denne beregner giver den teoretiske molekylvægt baseret på aminosyresekvensen med høj nøjagtighed. Den bruger de standard monoisotopiske masser af aminosyrer og tager højde for vandtab under dannelsen af peptidbindinger. Den tager dog ikke højde for post-translational modificeringer, ikke-standard aminosyrer eller isotopiske variationer, der måtte være til stede i virkelige proteiner.

Hvilke enheder bruges til protein molekylvægt?

Protein molekylvægte udtrykkes typisk i Daltons (Da) eller kilodaltons (kDa), hvor 1 kDa svarer til 1.000 Da. Dalton er cirka lig med massen af et hydrogenatom (1,66 × 10^-24 gram). Til reference kan små peptider være et par hundrede Da, mens store proteiner kan være hundreder af kDa.

Hvorfor adskiller min beregnede molekylvægt sig fra eksperimentelle værdier?

Flere faktorer kan forårsage uoverensstemmelser mellem beregnede og eksperimentelle molekylvægte:

1. Post-translational modificeringer (fosforylering, glykosylering osv.)
2. Dannelsen af disulfidbindinger
3. Proteolytisk behandling
4. Ikke-standard aminosyrer
5. Eksperimentelle målefejl
6. Isotopiske variationer

For præcis bestemmelse af molekylvægt for modificerede proteiner anbefales massespektrometri.

Kan denne beregner håndtere ikke-standard aminosyrer?

Denne beregner understøtter kun de 20 standard aminosyrer ved hjælp af deres en-bogstavs koder (A, R, N, D, C, E, Q, G, H, I, L, K, M, F, P, S, T, W, Y, V). For proteiner, der indeholder ikke-standard aminosyrer, selenocystein, pyrrolysine eller andre modificerede rester, vil specialiserede værktøjer eller manuelle beregninger være nødvendige.

Hvordan fortolker jeg aminosyrekompositionsresultaterne?

Aminosyrekompositionen viser tællingen og procentdelen af hver aminosyre i din proteinsekvens. Disse oplysninger er nyttige til:

• At forstå de fysiske egenskaber ved dit protein
• At identificere interessante områder (f.eks. hydrofobe områder)
• At planlægge eksperimentelle procedurer (f.eks. spektroskopiske målinger)
• At sammenligne lignende proteiner på tværs af arter

Hvad er forskellen mellem gennemsnitlig og monoisotopisk molekylvægt?

• Monoisotopisk molekylvægt bruger massen af den mest almindelige isotop af hvert element (hvad denne beregner giver)
• Gennemsnitlig molekylvægt bruger den vægtede gennemsnit af alle naturligt forekommende isotoper

For små peptider er forskellen minimal, men den bliver mere betydelig for større proteiner. Massespektrometri måler typisk monoisotopiske masser for mindre molekyler og gennemsnitlige masser for større.

Hvordan håndterer beregneren N-terminal og C-terminal grupper?

Beregneren tager højde for de standard N-terminal (NH₂-) og C-terminal (-COOH) grupper ved at tilføje et vandmolekyle (18.01528 Da) tilbage efter at have trukket vandet tabt i dannelsen af peptidbindinger. Dette sikrer, at den beregnede molekylvægt repræsenterer det komplette protein med de korrekte terminalgrupper.

Kan jeg beregne molekylvægten af et protein med disulfidbindinger?

Ja, men denne beregner justerer ikke automatisk for disulfidbindinger. Hver dannelse af en disulfidbinding resulterer i tabet af to hydrogenatomer (2.01588 Da). For at tage højde for disulfidbindinger skal du trække 2.01588 Da fra den beregnede molekylvægt for hver disulfidbinding i dit protein.

Hvordan relaterer protein molekylvægt sig til protein størrelse?

Selvom molekylvægt korrelerer med protein størrelse, er forholdet ikke altid ligetil. Faktorer, der påvirker den fysiske størrelse af et protein, inkluderer:

• Aminosyrekomposition
• Sekundær og tertiær struktur
• Hydratiseringsskaller
• Post-translational modificeringer
• Miljømæssige forhold (pH, salt koncentration)

For et groft estimat har et globulært protein på 10 kDa en diameter på cirka 2-3 nm.

Referencer

1. Gasteiger E., Hoogland C., Gattiker A., Duvaud S., Wilkins M.R., Appel R.D., Bairoch A. (2005) Protein Identifikation og Analyseværktøjer på ExPASy Serveren. I: Walker J.M. (red.) The Proteomics Protocols Handbook. Humana Press.

2. Nelson, D. L., & Cox, M. M. (2017). Lehninger Principles of Biochemistry (7. udg.). W.H. Freeman and Company.

3. Steen, H., & Mann, M. (2004). ABC'erne (og XYZ'erne) ved peptidsekventering. Nature Reviews Molecular Cell Biology, 5(9), 699-711.

4. Voet, D., Voet, J. G., & Pratt, C. W. (2016). Fundamentals of Biochemistry: Life at the Molecular Level (5. udg.). Wiley.

5. Creighton, T. E. (2010). The Biophysical Chemistry of Nucleic Acids & Proteins. Helvetian Press.

6. UniProt Consortium. (2021). UniProt: den universelle proteinvidensdatabase i 2021. Nucleic Acids Research, 49(D1), D480-D489.

7. Artimo, P., Jonnalagedda, M., Arnold, K., Baratin, D., Csardi, G., de Castro, E., Duvaud, S., Flegel, V., Fortier, A., Gasteiger, E., Grosdidier, A., Hernandez, C., Ioannidis, V., Kuznetsov, D., Liechti, R., Moretti, S., Mostaguir, K., Redaschi, N., Rossier, G., Xenarios, I., & Stockinger, H. (2012). ExPASy: SIB bioinformatik ressource portal. Nucleic Acids Research, 40(W1), W597-W603.

8. Kinter, M., & Sherman, N. E. (2005). Proteinsekventering og identifikation ved hjælp af tandem massespektrometri. Wiley-Interscience.

Prøv vores Protein Molekylvægt Beregner i dag for hurtigt og præcist at bestemme molekylvægten af dine proteinsekvenser. Uanset om du planlægger eksperimenter, analyserer resultater eller lærer om proteinbiokemi, giver dette værktøj de oplysninger, du har brug for på få sekunder.