Proteinmolekylviktkalkylator

Introduktion

Proteinmolekylviktkalkylatorn är ett viktigt verktyg för biokemister, molekylärbiologer och proteinkunniga som behöver bestämma massan av proteiner baserat på deras aminosyrasekvenser. Proteiner är komplexa makromolekyler som består av aminosyrakedjor, och att känna till deras molekylvikt är avgörande för olika laboratorietekniker, experimentell design och dataanalys. Denna kalkylator ger ett snabbt och exakt sätt att uppskatta molekylvikten av vilket protein som helst med hjälp av dess aminosyrasekvens, vilket sparar forskare värdefull tid och minskar risken för beräkningsfel.

Proteinmolekylvikt, ofta uttryckt i Dalton (Da) eller kilodalton (kDa), representerar summan av de individuella vikterna av alla aminosyror i proteinet, med hänsyn till de vattenmolekyler som förloras under bildandet av peptidbindningar. Denna grundläggande egenskap påverkar proteinets beteende i lösning, elektroforesmobilitet, kristallisationsegenskaper och många andra fysikaliska och kemiska egenskaper som är viktiga inom forskning och industriella tillämpningar.

Vår användarvänliga kalkylator kräver endast den enbokstavs aminosyrasekvensen för ditt protein för att generera exakta uppskattningar av molekylvikten, vilket gör den tillgänglig för både erfarna forskare och studenter som är nya inom proteinkemi.

Hur proteinmolekylvikt beräknas

Grundformeln

Molekylvikten av ett protein beräknas med hjälp av följande formel:

$MW_{protein} = \sum_{i=1}^{n} MW_{aminosyra_i} - (n-1) \times MW_{vatten} + MW_{vatten}$

Där:

• $MW_{protein}$ är molekylvikten av hela proteinet i Dalton (Da)
• $\sum_{i=1}^{n} MW_{aminosyra_i}$ är summan av molekylvikterna av alla individuella aminosyror
• $n$ är antalet aminosyror i sekvensen
• $MW_{vatten}$ är molekylvikten av vatten (18.01528 Da)
• $(n-1)$ representerar antalet peptidbindningar som bildas
• Den sista $+ MW_{vatten}$ termen tar hänsyn till terminalgrupperna (H och OH)

Molekylvikter för aminosyror

Beräkningen använder de standardmolekylvikter för de 20 vanliga aminosyrorna:

Vattenförlust vid bildande av peptidbindningar

När aminosyror går samman för att bilda ett protein skapar de peptidbindningar. Under denna process frigörs en vattenmolekyl (H₂O) för varje bindning som bildas. Denna vattenförlust måste beaktas i beräkningen av molekylvikten.

För ett protein med n aminosyror bildas (n-1) peptidbindningar, vilket resulterar i förlusten av (n-1) vattenmolekyler. Men vi lägger tillbaka en vattenmolekyl för att ta hänsyn till terminalgrupperna (H vid N-terminalen och OH vid C-terminalen).

Exempelberäkning

Låt oss beräkna molekylvikten av en enkel tripeptid: Ala-Gly-Ser (AGS)

1. Summera vikterna av individuella aminosyror:

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

2. Subtrahera vattenförlusten från peptidbindningar:

   • Antal peptidbindningar = 3-1 = 2
   • Vattenmolekylvikt = 18.01528 Da
   • Total vattenförlust = 2 × 18.01528 = 36.03056 Da

3. Lägg tillbaka en vattenmolekyl för terminalgrupper:

   • 18.01528 Da

4. Slutlig molekylvikt:

   • 215.0906 - 36.03056 + 18.01528 = 197.07532 Da

Hur man använder denna kalkylator

Att använda Proteinmolekylviktkalkylatorn är enkelt:

1. Ange din proteinsekvens i textfältet med hjälp av de standard en-bokstavs aminosyrakoderna (A, R, N, D, C, E, Q, G, H, I, L, K, M, F, P, S, T, W, Y, V).

2. Kalkylatorn kommer att automatiskt validera din inmatning för att säkerställa att den endast innehåller giltiga aminosyrakoder.

3. Klicka på "Beräkna molekylvikt"-knappen eller vänta på att den automatiska beräkningen ska slutföras.

4. Se resultaten, som inkluderar:

   • Den beräknade molekylvikten i Dalton (Da)
   • Sekvenslängden (antal aminosyror)
   • En sammanställning av aminosyresammansättningen
   • Formeln som används för beräkning

5. Du kan kopiera resultaten till ditt urklipp genom att klicka på "Kopiera"-knappen för användning i rapporter eller vidare analys.

Inmatningsriktlinjer

För exakta resultat, följ dessa riktlinjer när du anger din proteinsekvens:

• Använd endast de standard en-bokstavs aminosyrakoderna (stora eller små bokstäver)
• Inkludera inte mellanslag, siffror eller specialtecken
• Ta bort alla icke-aminosyrakaraktärer (såsom sekvensnummer)
• För sekvenser med icke-standard aminosyror, överväg att använda alternativa verktyg som stöder utvidgade aminosyrakoder

Tolkning av resultaten

Kalkylatorn ger flera bitar av information:

1. Molekylvikt: Den uppskattade molekylvikten av ditt protein i Dalton (Da). För större proteiner kan detta uttryckas i kilodalton (kDa).

2. Sekvenslängd: Det totala antalet aminosyror i din sekvens.

3. Aminosyrasammansättning: En visuell sammanställning av aminosyreinnehållet i ditt protein, som visar både antalet och procentandelen av varje aminosyra.

4. Beräkningsmetod: En tydlig förklaring av hur molekylvikten beräknades, inklusive den använda formeln.

Användningsområden

Proteinmolekylviktkalkylatorn har många tillämpningar inom olika områden av livsvetenskaper:

Proteinrening och analys

Forskare använder molekylviktsinformation för att:

• Ställa in lämpliga gel-filtreringskolonner
• Bestämma lämpliga polyakrylamidgelkoncentrationer för SDS-PAGE
• Tolka masspektrometridata
• Validera proteinuttryck och reningsresultat

Rekombinant proteinproduktion

Bioteknikföretag förlitar sig på exakta molekylviktsberäkningar för att:

• Utforma expressionskonstruktioner
• Uppskatta proteinutbyten
• Utveckla reningsstrategier
• Karakterisera slutprodukter

Peptidsyntes

Peptidkemister använder molekylviktsberäkningar för att:

• Bestämma mängden startmaterial som behövs
• Beräkna teoretiska utbyten
• Verifiera identiteten av syntetiserade peptider
• Utforma analytiska metoder för kvalitetskontroll

Strukturell biologi

Strukturella biologer behöver molekylviktsinformation för att:

• Ställa in kristalliseringstest
• Tolka röntgendiffraktionsdata
• Analysera proteincomplex
• Beräkna stökiometri av protein-protein-interaktioner

Läkemedelsutveckling

Läkemedelsutvecklare använder proteinmolekylvikt för att:

• Karakterisera terapeutiska proteiner
• Utveckla formuleringstrategier
• Utforma analytiska metoder
• Fastställa kvalitetskontrollspecifikationer

Akademisk forskning

Studenter och forskare använder kalkylatorn för:

• Laboratorieexperiment
• Dataanalys
• Experimentell design
• Utbildningsändamål

Alternativ

Även om vår Proteinmolekylviktkalkylator ger snabba och exakta uppskattningar, finns det alternativa metoder för att bestämma proteinmolekylvikt:

1. Experimentella metoder:

   • Masspektrometri (MS): Ger mycket exakta molekylviktsmätningar och kan upptäcka post-översättningsmodifieringar
   • Storleksutskiljande kromatografi (SEC): Uppskattar molekylvikt baserat på hydrodynamisk radie
   • SDS-PAGE: Ger ungefärlig molekylvikt baserat på elektroforetisk mobilitet

2. Andra beräkningsverktyg:

   • ExPASy ProtParam: Erbjuder ytterligare proteinparametrar utöver molekylvikt
   • EMBOSS Pepstats: Ger detaljerad statistisk analys av proteinsekvenser
   • Protein Calculator v3.4: Inkluderar ytterligare beräkningar som isoelektrisk punkt och extinctionkoefficient

3. Specialiserad programvara:

   • För proteiner med icke-standard aminosyror eller post-översättningsmodifieringar
   • För komplexa proteinaggregat eller multimera proteiner
   • För isotopiskt märkta proteiner som används i NMR-studier

Historik om bestämning av proteinmolekylvikt

Begreppet molekylvikt har varit grundläggande för kemin sedan John Dalton föreslog sin atomteori i början av 1800-talet. Men tillämpningen på proteiner har en mer recent historia:

Tidig proteinkemi (1800-talet-1920-talet)

• År 1838 myntade Jöns Jacob Berzelius termen "protein" från det grekiska ordet "proteios," som betyder "primär" eller "av första vikt."
• Tidiga proteinkunniga som Frederick Sanger började förstå att proteiner var sammansatta av aminosyror.
• Begreppet proteiner som makromolekyler med definierade molekylvikter framträdde gradvis.

Utveckling av analytiska tekniker (1930-talet-1960-talet)

• Uppfinningen av ultracentrifugering av Theodor Svedberg på 1920-talet möjliggjorde de första exakta mätningarna av proteinmolekylvikter.
• Utvecklingen av elektroforesmetoder på 1930-talet av Arne Tiselius gav en annan metod för att uppskatta proteinets storlek.
• År 1958 fullföljde Stanford Moore och William H. Stein den första fullständiga aminosyrasekvensen av ribonukleas, vilket möjliggjorde exakt beräkning av molekylvikt.

Modern tid (1970-talet-nutid)

• Utvecklingen av masspektrometritekniker revolutionerade bestämningen av proteinmolekylvikt.
• John Fenn och Koichi Tanaka fick Nobelpriset i kemi 2002 för sin utveckling av mjuka desorptionsionisationsmetoder för masspektrometriska analyser av biologiska makromolekyler.
• Beräkningsmetoder för att förutsäga proteinets egenskaper, inklusive molekylvikt, blev alltmer sofistikerade och tillgängliga.
• Framväxten av genomik och proteomik på 1990-talet och 2000-talet skapade ett behov av höggenomströmningsanalysverktyg för protein, inklusive automatiserade molekylviktkalkylatorer.

Idag är beräkning av proteinmolekylvikt en rutinmässig men väsentlig del av proteinkemi, underlättad av verktyg som vår kalkylator som gör dessa beräkningar tillgängliga för forskare världen över.

Kodexempel

Här är exempel på hur man beräknar proteinmolekylvikt i olika programmeringsspråk:

1' Excel VBA-funktion för beräkning av proteinmolekylvikt
2Function ProteinMolecularWeight(sequence As String) As Double
3    ' Aminosyra molekylvikter
4    Dim aaWeights As Object
5    Set aaWeights = CreateObject("Scripting.Dictionary")
6    
7    ' Initiera aminosyrevikt
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    ' Vattenmolekylvikt
30    Const WATER_WEIGHT As Double = 18.01528
31    
32    ' Konvertera sekvens till versaler
33    sequence = UCase(sequence)
34    
35    ' Beräkna totalvikt
36    Dim totalWeight As Double
37    totalWeight = 0
38    
39    ' Summera individuella aminosyrevikt
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            ' Ogiltig aminosyrakod
49            ProteinMolecularWeight = -1
50            Exit Function
51        End If
52    Next i
53    
54    ' Subtrahera vattenförlust från peptidbindningar och lägg till terminalvatten
55    Dim numAminoAcids As Integer
56    numAminoAcids = Len(sequence)
57    
58    ProteinMolecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT
59End Function
60
61' Användning i Excel:
62' =ProteinMolecularWeight("ACDEFGHIKLMNPQRSTVWY")
63

1def calculate_protein_molecular_weight(sequence):
2    """
3    Beräkna molekylvikten av ett protein från dess aminosyrasekvens.
4    
5    Args:
6        sequence (str): Proteinsekvens med en-bokstavs aminosyrakoder
7        
8    Returns:
9        float: Molekylvikt i Dalton (Da)
10    """
11    # Aminosyra molekylvikter
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    # Vattenmolekylvikt
36    WATER_WEIGHT = 18.01528
37    
38    # Konvertera sekvens till versaler
39    sequence = sequence.upper()
40    
41    # Validera sekvens
42    for aa in sequence:
43        if aa not in aa_weights:
44            raise ValueError(f"Ogiltig aminosyrakod: {aa}")
45    
46    # Summera individuella aminosyrevikt
47    total_weight = sum(aa_weights[aa] for aa in sequence)
48    
49    # Subtrahera vattenförlust från peptidbindningar och lägg till terminalvatten
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# Exempelanvändning:
56sequence = "MVKMDVYKGSSIGDSMSRSM"
57mw = calculate_protein_molecular_weight(sequence)
58print(f"Molekylvikt: {mw:.2f} Da")
59

1function calculateProteinMolecularWeight(sequence) {
2  // Aminosyra molekylvikter
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  // Vattenmolekylvikt
27  const WATER_WEIGHT = 18.01528;
28  
29  // Konvertera sekvens till versaler
30  sequence = sequence.toUpperCase();
31  
32  // Validera sekvens
33  for (let i = 0; i < sequence.length; i++) {
34    const aa = sequence[i];
35    if (!aaWeights[aa]) {
36      throw new Error(`Ogiltig aminosyrakod: ${aa}`);
37    }
38  }
39  
40  // Summera individuella aminosyrevikt
41  let totalWeight = 0;
42  for (let i = 0; i < sequence.length; i++) {
43    totalWeight += aaWeights[sequence[i]];
44  }
45  
46  // Subtrahera vattenförlust från peptidbindningar och lägg till terminalvatten
47  const numAminoAcids = sequence.length;
48  const molecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT;
49  
50  return molecularWeight;
51}
52
53// Exempelanvändning:
54const sequence = "ACDEFGHIKLMNPQRSTVWY";
55try {
56  const mw = calculateProteinMolecularWeight(sequence);
57  console.log(`Molekylvikt: ${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        // Initiera aminosyrevikt
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        // Konvertera sekvens till versaler
34        sequence = sequence.toUpperCase();
35        
36        // Validera 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("Ogiltig aminosyrakod: " + aa);
41            }
42        }
43        
44        // Summera individuella aminosyrevikt
45        double totalWeight = 0;
46        for (int i = 0; i < sequence.length(); i++) {
47            totalWeight += aminoAcidWeights.get(sequence.charAt(i));
48        }
49        
50        // Subtrahera vattenförlust från peptidbindningar och lägg till terminalvatten
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("Molekylvikt: %.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    // Aminosyra molekylvikter
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    // Vattenmolekylvikt
33    const double WATER_WEIGHT = 18.01528;
34    
35    // Konvertera sekvens till versaler
36    std::string upperSequence = sequence;
37    std::transform(upperSequence.begin(), upperSequence.end(), upperSequence.begin(), ::toupper);
38    
39    // Validera sekvens
40    for (char aa : upperSequence) {
41        if (aaWeights.find(aa) == aaWeights.end()) {
42            throw std::invalid_argument(std::string("Ogiltig aminosyrakod: ") + aa);
43        }
44    }
45    
46    // Summera individuella aminosyrevikt
47    double totalWeight = 0.0;
48    for (char aa : upperSequence) {
49        totalWeight += aaWeights[aa];
50    }
51    
52    // Subtrahera vattenförlust från peptidbindningar och lägg till terminalvatten
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 << "Molekylvikt: " << std::fixed << std::setprecision(2) << mw << " Da" << std::endl;
64    } catch (const std::exception& e) {
65        std::cerr << "Fel: " << e.what() << std::endl;
66    }
67    
68    return 0;
69}
70

Vanliga frågor

Vad är proteinmolekylvikt?

Proteinmolekylvikt, även kallad molekylmassa, är den totala massan av en proteinmolekyl uttryckt i Dalton (Da) eller kilodalton (kDa). Den representerar summan av massorna av alla atomer i proteinet, med hänsyn till förlusten av vattenmolekyler under bildandet av peptidbindningar. Denna grundläggande egenskap är avgörande för proteinets karakterisering, rening och analys.

Hur exakt är denna proteinmolekylviktkalkylator?

Denna kalkylator ger den teoretiska molekylvikten baserat på aminosyrasekvensen med hög noggrannhet. Den använder de standardmonoisotopiska massorna av aminosyror och tar hänsyn till vattenförlusten under bildandet av peptidbindningar. Den tar dock inte hänsyn till post-översättningsmodifieringar, icke-standard aminosyror eller isotopiska variationer som kan finnas i verkliga proteiner.

Vilka enheter används för proteinmolekylvikt?

Proteinmolekylvikter uttrycks vanligtvis i Dalton (Da) eller kilodalton (kDa), där 1 kDa är lika med 1 000 Da. Dalton är ungefär lika med massan av en väteatom (1,66 × 10^-24 gram). Som referens kan små peptider vara några hundra Da, medan stora proteiner kan vara hundratals kDa.

Varför skiljer sig min beräknade molekylvikt från experimentella värden?

Flera faktorer kan orsaka avvikelser mellan beräknade och experimentella molekylvikter:

1. Post-översättningsmodifieringar (fosforylering, glykosylering etc.)
2. Disulfidbindningsbildning
3. Proteolytisk bearbetning
4. Icke-standard aminosyror
5. Experimentella mätfel
6. Isotopiska variationer

För noggrann bestämning av molekylvikten för modifierade proteiner rekommenderas masspektrometri.

Kan denna kalkylator hantera icke-standard aminosyror?

Denna kalkylator stöder endast de 20 standard aminosyrorna med deras en-bokstavskoder (A, R, N, D, C, E, Q, G, H, I, L, K, M, F, P, S, T, W, Y, V). För proteiner som innehåller icke-standard aminosyror, selenocystein, pyrrolysine eller andra modifierade rester, skulle specialiserade verktyg eller manuella beräkningar krävas.

Hur tolkar jag resultaten av aminosyrasammansättningen?

Aminosyrasammansättningen visar antalet och procentandelen av varje aminosyra i din proteinsekvens. Denna information är användbar för:

• Att förstå de fysikaliska egenskaperna hos ditt protein
• Att identifiera intressanta områden (t.ex. hydrofoba fläckar)
• Att planera experimentella procedurer (t.ex. spektroskopiska mätningar)
• Att jämföra liknande proteiner över arter

Vad är skillnaden mellan genomsnittlig och monoisotopisk molekylvikt?

• Monoisotopisk molekylvikt använder massan av den mest förekommande isotopen av varje element (vad denna kalkylator tillhandahåller)
• Genomsnittlig molekylvikt använder det viktade genomsnittet av alla naturligt förekommande isotoper

För små peptider är skillnaden minimal, men den blir mer betydande för större proteiner. Masspektrometri mäter typiskt monoisotopiska massor för mindre molekyler och genomsnittliga massor för större.

Hur hanterar kalkylatorn N-terminala och C-terminala grupper?

Kalkylatorn tar hänsyn till de standard N-terminala (NH₂-) och C-terminala (-COOH) grupperna genom att lägga tillbaka en vattenmolekyl (18.01528 Da) efter att ha subtraherat vattnet som förloras i peptidbindningarna. Detta säkerställer att den beräknade molekylvikten representerar det kompletta proteinet med korrekta terminalgrupper.

Kan jag beräkna molekylvikten av ett protein med disulfidbindningar?

Ja, men denna kalkylator justerar inte automatiskt för disulfidbindningar. Varje disulfidbindning resulterar i förlust av två väteatomer (2.01588 Da). För att ta hänsyn till disulfidbindningar, subtrahera 2.01588 Da från den beräknade molekylvikten för varje disulfidbindning i ditt protein.

Hur relaterar proteinmolekylvikt till proteins storlek?

Även om molekylvikt korrelerar med proteins storlek, är relationen inte alltid rak. Faktorer som påverkar proteinets fysiska storlek inkluderar:

• Aminosyrasammansättning
• Sekundär och tertiär struktur
• Hydratiseringsskikt
• Post-översättningsmodifieringar
• Miljöförhållanden (pH, salthalt)

För en grov uppskattning har ett globulärt protein på 10 kDa en diameter på cirka 2-3 nm.

Referenser

1. Gasteiger E., Hoogland C., Gattiker A., Duvaud S., Wilkins M.R., Appel R.D., Bairoch A. (2005) Protein Identification and Analysis Tools on the ExPASy Server. In: Walker J.M. (eds) The Proteomics Protocols Handbook. Humana Press.

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

3. Steen, H., & Mann, M. (2004). The ABC's (and XYZ's) of peptide sequencing. 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 (5th ed.). Wiley.

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

6. UniProt Consortium. (2021). UniProt: the universal protein knowledgebase in 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 bioinformatics resource portal. Nucleic Acids Research, 40(W1), W597-W603.

8. Kinter, M., & Sherman, N. E. (2005). Protein Sequencing and Identification Using Tandem Mass Spectrometry. Wiley-Interscience.

Prova vår Proteinmolekylviktkalkylator idag för att snabbt och exakt bestämma molekylvikten av dina proteinsekvenser. Oavsett om du planerar experiment, analyserar resultat eller lär dig om proteinbiokemi, ger detta verktyg den information du behöver på sekunder.