Protein Molekylvektorkalkulator

Introduksjon

Protein molekylvektorkalkulatoren er et essensielt verktøy for biokjemikere, molekylærbiologer og proteinscientister som trenger å bestemme massen av proteiner basert på deres aminosyresekvenser. Proteiner er komplekse makromolekyler sammensatt av aminosyrekjeder, og å kjenne deres molekylvekt er avgjørende for ulike laboratorieteknikker, eksperimentell design og dataanalyse. Denne kalkulatoren gir en rask og nøyaktig måte å estimere molekylvekten av ethvert protein ved å bruke dets aminosyresekvens, og sparer forskere verdifull tid og reduserer potensialet for beregningsfeil.

Protein molekylvekt, ofte uttrykt i Dalton (Da) eller kilodalton (kDa), representerer summen av de individuelle vektene av alle aminosyrer i proteinet, med hensyn til vannmolekylene som går tapt under dannelsen av peptidbindinger. Denne grunnleggende egenskapen påvirker proteinoppførselen i løsning, elektroforese mobilitet, krystalliseringsegenskaper og mange andre fysiske og kjemiske egenskaper som er viktige i forskning og industrielle applikasjoner.

Vår brukervennlige kalkulator krever bare den enbokstavs aminosyresekvensen til proteinet ditt for å generere nøyaktige molekylvektestimater, noe som gjør den tilgjengelig for både erfarne forskere og studenter som er nye innen proteinscience.

Hvordan protein molekylvekt beregnes

Den grunnleggende formelen

Molekylvekten til et protein beregnes ved hjelp av følgende formel:

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

Hvor:

• $MW_{protein}$ er molekylvekten til hele proteinet i Dalton (Da)
• $\sum_{i=1}^{n} MW_{aminosyre_i}$ er summen av molekylvektene til alle individuelle aminosyrer
• $n$ er antallet aminosyrer i sekvensen
• $MW_{vann}$ er molekylvekten av vann (18.01528 Da)
• $(n-1)$ representerer antallet peptidbindinger som dannes
• Den siste $+ MW_{vann}$ termen tar hensyn til terminalgruppene (H og OH)

Aminosyre molekylvekter

Beregningen bruker de standard molekylvektene til de 20 vanlige aminosyrene:

Vann tap i peptidbindingdannelse

Når aminosyrer går sammen for å danne et protein, skaper de peptidbindinger. Under denne prosessen frigjøres et vannmolekyl (H₂O) for hver binding som dannes. Dette vannet tapet må tas hensyn til i beregningen av molekylvekten.

For et protein med n aminosyrer, dannes det (n-1) peptidbindinger, noe som resulterer i tapet av (n-1) vannmolekyler. Imidlertid legger vi tilbake ett vannmolekyl for å ta hensyn til terminalgruppene (H ved N-terminalen og OH ved C-terminalen).

Eksempelberegning

La oss beregne molekylvekten til et enkelt tripeptid: Ala-Gly-Ser (AGS)

1. Summere vektene av individuelle aminosyrer:

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

2. Trekk fra vann tap fra peptidbindinger:

   • Antall peptidbindinger = 3-1 = 2
   • Vann molekylvekt = 18.01528 Da
   • Totalt vann tap = 2 × 18.01528 = 36.03056 Da

3. Legg tilbake ett vannmolekyl for terminalgrupper:

   • 18.01528 Da

4. Endelig molekylvekt:

   • 215.0906 - 36.03056 + 18.01528 = 197.07532 Da

Hvordan bruke denne kalkulatoren

Å bruke Protein molekylvektorkalkulatoren er enkelt:

1. Skriv inn proteinsekvensen i tekstboksen ved å bruke de standard en-bokstavs aminosyrekodene (A, R, N, D, C, E, Q, G, H, I, L, K, M, F, P, S, T, W, Y, V).

2. Kalkulatoren vil automatisk validere inndataene dine for å sikre at de bare inneholder gyldige aminosyrekoder.

3. Klikk på "Beregn molekylvekt"-knappen eller vent på at den automatiske beregningen skal fullføres.

4. Se resultatene, som inkluderer:

   • Den beregnede molekylvekten i Dalton (Da)
   • Sekvenslengden (antall aminosyrer)
   • En oppdeling av aminosyrekomposisjon
   • Formelen som ble brukt for beregning

5. Du kan kopiere resultatene til utklippstavlen ved å klikke på "Kopier"-knappen for bruk i rapporter eller videre analyse.

Inndataretningslinjer

For nøyaktige resultater, følg disse retningslinjene når du skriver inn proteinsekvensen din:

• Bruk kun de standard en-bokstavs aminosyrekodene (store eller små bokstaver)
• Ikke inkluder mellomrom, tall eller spesialtegn
• Fjern eventuelle ikke-aminosyre tegn (som sekvensnummerering)
• For sekvenser med ikke-standard aminosyrer, vurder å bruke alternative verktøy som støtter utvidede aminosyrekoder

Tolkning av resultatene

Kalkulatoren gir flere informasjonsbiter:

1. Molekylvekt: Den estimerte molekylvekten til proteinet ditt i Dalton (Da). For større proteiner kan dette uttrykkes i kilodalton (kDa).

2. Sekvenslengde: Det totale antallet aminosyrer i sekvensen din.

3. Aminosyrekomposisjon: En visuell oppdeling av aminosyreinnholdet i proteinet ditt, som viser både antallet og prosentandelen av hver aminosyre.

4. Beregningmetode: En klar forklaring på hvordan molekylvekten ble beregnet, inkludert formelen som ble brukt.

Bruksområder

Protein molekylvektorkalkulatoren har mange applikasjoner på tvers av ulike felt innen livsvitenskap:

Proteinrening og analyse

Forskere bruker molekylvektinformasjon til å:

• Sette opp passende gel-filtreringskolonner
• Bestemme passende polyakrylamidgelkonsentrasjoner for SDS-PAGE
• Tolke massespektrometridata
• Validere proteinuttrykk og rensingsresultater

Rekombinant proteinproduksjon

Bioteknologiselskaper er avhengige av nøyaktige molekylvektberegninger for å:

• Designe uttrykkskonstruksjoner
• Estimere proteinutbytter
• Utvikle rensingsstrategier
• Karakterisere sluttprodukter

Peptidsyntese

Peptidkjemikere bruker molekylvektberegninger til å:

• Bestemme mengden av startmaterialer som trengs
• Beregne teoretiske utbytter
• Bekrefte identiteten til syntetiserte peptider
• Designe analytiske metoder for kvalitetskontroll

Strukturbiologi

Strukturbiologer trenger molekylvektinformasjon for å:

• Sette opp krystalliseringsforsøk
• Tolke røntgendiffraksjonsdata
• Analysere protein komplekser
• Beregne stoikiometri av protein-protein interaksjoner

Legemiddelutvikling

Legemiddelutviklere bruker protein molekylvekt til å:

• Karakterisere terapeutiske proteiner
• Utvikle formuleringsstrategier
• Designe analytiske metoder
• Etablere spesifikasjoner for kvalitetskontroll

Akademisk forskning

Studenter og forskere bruker kalkulatoren til:

• Laboratorieforsøk
• Dataanalyse
• Eksperimentell design
• Utdanningsformål

Alternativer

Selv om vår Protein molekylvektorkalkulator gir raske og nøyaktige estimater, finnes det alternative tilnærminger for å bestemme protein molekylvekt:

1. Eksperimentelle metoder:

   • Massespektrometri (MS): Gir svært nøyaktige molekylvektsmålinger og kan oppdage post-translasjonsmodifikasjoner
   • Størrelseseksklusjonskromatografi (SEC): Estimerer molekylvekt basert på hydrodynamisk radius
   • SDS-PAGE: Gir omtrentlig molekylvekt basert på elektroforetisk mobilitet

2. Andre beregningsverktøy:

   • ExPASy ProtParam: Tilbyr ytterligere proteinparametere utover molekylvekt
   • EMBOSS Pepstats: Gir detaljert statistisk analyse av proteinsekvenser
   • Protein Calculator v3.4: Inkluderer ytterligere beregninger som isoelektrisk punkt og ekstensjonskoeffisient

3. Spesialisert programvare:

   • For proteiner med ikke-standard aminosyrer eller post-translasjonsmodifikasjoner
   • For komplekse proteinassemblager eller multimere proteiner
   • For isotopisk merkede proteiner brukt i NMR-studier

Historie om bestemmelse av protein molekylvekt

Begrepet molekylvekt har vært fundamentalt for kjemi siden John Dalton foreslo sin atomteori på tidlig 1800-tallet. Imidlertid har anvendelsen på proteiner en mer nylig historie:

Tidlig proteinvitenskap (1800-tallet-1920-tallet)

• I 1838 myntet Jöns Jacob Berzelius begrepet "protein" fra det greske ordet "proteios," som betyr "primær" eller "av første viktighet."
• Tidlige proteinforskere som Frederick Sanger begynte å forstå at proteiner var sammensatt av aminosyrer.
• Begrepet proteiner som makromolekyler med definerte molekylvekter dukket gradvis opp.

Utvikling av analytiske teknikker (1930-tallet-1960-tallet)

• Oppfinnelsen av ultraseskentrifugering av Theodor Svedberg på 1920-tallet tillot de første nøyaktige målingene av protein molekylvekter.
• Utviklingen av elektroforese teknikker på 1930-tallet av Arne Tiselius ga en annen metode for å estimere protein størrelse.
• I 1958 fullførte Stanford Moore og William H. Stein den første fullstendige aminosyresekvensen av ribonuklease, noe som tillot presis beregning av molekylvekt.

Moderne tid (1970-tallet-nåtid)

• Utviklingen av massespektrometri teknikker revolusjonerte bestemmelsen av protein molekylvekt.
• John Fenn og Koichi Tanaka mottok Nobelprisen i kjemi i 2002 for deres utvikling av myke desorpsjonsioniseringsmetoder for massespektrometriske analyser av biologiske makromolekyler.
• Beregningsmetoder for å forutsi proteinparametere, inkludert molekylvekt, ble stadig mer sofistikerte og tilgjengelige.
• Fremveksten av genomikk og proteomikk på 1990-tallet og 2000-tallet skapte et behov for høy gjennomstrømnings proteinanalysetools, inkludert automatiserte molekylvekt kalkulatorer.

I dag er beregning av protein molekylvekt en rutine, men essensiell del av proteinvitenskap, lettet av verktøy som vår kalkulator som gjør disse beregningene tilgjengelige for forskere over hele verden.

Kodeeksempler

Her er eksempler på hvordan man kan beregne protein molekylvekt i forskjellige programmeringsspråk:

1' Excel VBA-funksjon for beregning av protein molekylvekt
2Function ProteinMolecularWeight(sequence As String) As Double
3    ' Aminosyre molekylvekter
4    Dim aaWeights As Object
5    Set aaWeights = CreateObject("Scripting.Dictionary")
6    
7    ' Initialiser aminosyrevekter
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    ' Vann molekylvekt
30    Const WATER_WEIGHT As Double = 18.01528
31    
32    ' Konverter sekvensen til store bokstaver
33    sequence = UCase(sequence)
34    
35    ' Beregn totalvekt
36    Dim totalWeight As Double
37    totalWeight = 0
38    
39    ' Summere individuelle aminosyrevekter
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 aminosyrekode
49            ProteinMolecularWeight = -1
50            Exit Function
51        End If
52    Next i
53    
54    ' Trekk fra vann tap fra peptidbindinger og legg tilbake terminalvann
55    Dim numAminoAcids As Integer
56    numAminoAcids = Len(sequence)
57    
58    ProteinMolecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT
59End Function
60
61' Bruk i Excel:
62' =ProteinMolecularWeight("ACDEFGHIKLMNPQRSTVWY")
63

1def calculate_protein_molecular_weight(sequence):
2    """
3    Beregn molekylvekten til et protein fra dets aminosyresekvens.
4    
5    Args:
6        sequence (str): Proteinsekvens som bruker en-bokstavs aminosyrekoder
7        
8    Returns:
9        float: Molekylvekt i Dalton (Da)
10    """
11    # Aminosyre molekylvekter
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    # Vann molekylvekt
36    WATER_WEIGHT = 18.01528
37    
38    # Konverter sekvensen til store bokstaver
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 aminosyrekode: {aa}")
45    
46    # Summere individuelle aminosyrevekter
47    total_weight = sum(aa_weights[aa] for aa in sequence)
48    
49    # Trekk fra vann tap fra peptidbindinger og legg tilbake terminalvann
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å bruk:
56sequence = "MVKMDVYKGSSIGDSMSRSM"
57mw = calculate_protein_molecular_weight(sequence)
58print(f"Molekylvekt: {mw:.2f} Da")
59

1function calculateProteinMolecularWeight(sequence) {
2  // Aminosyre molekylvekter
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  // Vann molekylvekt
27  const WATER_WEIGHT = 18.01528;
28  
29  // Konverter sekvensen til store bokstaver
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 aminosyrekode: ${aa}`);
37    }
38  }
39  
40  // Summere individuelle aminosyrevekter
41  let totalWeight = 0;
42  for (let i = 0; i < sequence.length; i++) {
43    totalWeight += aaWeights[sequence[i]];
44  }
45  
46  // Trekk fra vann tap fra peptidbindinger og legg tilbake terminalvann
47  const numAminoAcids = sequence.length;
48  const molecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT;
49  
50  return molecularWeight;
51}
52
53// Eksempel på bruk:
54const sequence = "ACDEFGHIKLMNPQRSTVWY";
55try {
56  const mw = calculateProteinMolecularWeight(sequence);
57  console.log(`Molekylvekt: ${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 aminosyrevekter
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 sekvensen til store bokstaver
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 aminosyrekode: " + aa);
41            }
42        }
43        
44        // Summere individuelle aminosyrevekter
45        double totalWeight = 0;
46        for (int i = 0; i < sequence.length(); i++) {
47            totalWeight += aminoAcidWeights.get(sequence.charAt(i));
48        }
49        
50        // Trekk fra vann tap fra peptidbindinger og legg tilbake terminalvann
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("Molekylvekt: %.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 molekylvekter
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    // Vann molekylvekt
33    const double WATER_WEIGHT = 18.01528;
34    
35    // Konverter sekvensen til store bokstaver
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 aminosyrekode: ") + aa);
43        }
44    }
45    
46    // Summere individuelle aminosyrevekter
47    double totalWeight = 0.0;
48    for (char aa : upperSequence) {
49        totalWeight += aaWeights[aa];
50    }
51    
52    // Trekk fra vann tap fra peptidbindinger og legg tilbake terminalvann
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 << "Molekylvekt: " << std::fixed << std::setprecision(2) << mw << " Da" << std::endl;
64    } catch (const std::exception& e) {
65        std::cerr << "Feil: " << e.what() << std::endl;
66    }
67    
68    return 0;
69}
70

Vanlige spørsmål

Hva er protein molekylvekt?

Protein molekylvekt, også kalt molekylmasse, er den totale massen av et proteinmolekyl uttrykt i Dalton (Da) eller kilodalton (kDa). Det representerer summen av massene til alle atomene i proteinet, med hensyn til tapet av vannmolekyler under dannelsen av peptidbindinger. Denne grunnleggende egenskapen er avgjørende for protein karakterisering, rensing og analyse.

Hvor nøyaktig er denne protein molekylvekt kalkulatoren?

Denne kalkulatoren gir den teoretiske molekylvekten basert på aminosyresekvensen med høy nøyaktighet. Den bruker de standard monoisotopiske massene til aminosyrer og tar hensyn til vann tap under dannelsen av peptidbindinger. Imidlertid tar den ikke hensyn til post-translasjonsmodifikasjoner, ikke-standard aminosyrer eller isotopiske variasjoner som kan være til stede i virkelige proteiner.

Hvilke enheter brukes for protein molekylvekt?

Protein molekylvekter uttrykkes vanligvis i Dalton (Da) eller kilodalton (kDa), hvor 1 kDa tilsvarer 1 000 Da. Dalton er omtrent lik massen av et hydrogenatom (1.66 × 10^-24 gram). Som referanse kan små peptider være noen hundre Da, mens store proteiner kan være hundrevis av kDa.

Hvorfor er den beregnede molekylvekten min forskjellig fra eksperimentelle verdier?

Flere faktorer kan forårsake avvik mellom beregnede og eksperimentelle molekylvekter:

1. Post-translasjonsmodifikasjoner (fosforylering, glykosylering, osv.)
2. Disulfidbindinger
3. Proteolytisk prosessering
4. Ikke-standard aminosyrer
5. Eksperimentelle målefeil
6. Isotopiske variasjoner

For presis bestemmelse av molekylvekt for modifiserte proteiner anbefales massespektrometri.

Kan denne kalkulatoren håndtere ikke-standard aminosyrer?

Denne kalkulatoren støtter bare de 20 standard aminosyrene ved hjelp av deres en-bokstavskoder (A, R, N, D, C, E, Q, G, H, I, L, K, M, F, P, S, T, W, Y, V). For proteiner som inneholder ikke-standard aminosyrer, selenocystein, pyrrolysine, eller andre modifiserte rester, vil spesialiserte verktøy eller manuelle beregninger være nødvendige.

Hvordan tolker jeg aminosyrekomposisjonsresultatene?

Aminosyrekomposisjonen viser antallet og prosentandelen av hver aminosyre i proteinsekvensen din. Denne informasjonen er nyttig for:

• Å forstå de fysiske egenskapene til proteinet ditt
• Å identifisere områder av interesse (f.eks. hydrofobe områder)
• Å planlegge eksperimentelle prosedyrer (f.eks. spektroskopiske målinger)
• Å sammenligne lignende proteiner på tvers av arter

Hva er forskjellen mellom gjennomsnittlig og monoisotopisk molekylvekt?

• Monoisotopisk molekylvekt bruker massen av den mest vanlige isotopen av hvert element (det som denne kalkulatoren gir)
• Gjennomsnittlig molekylvekt bruker den vektede gjennomsnittet av alle naturlig forekommende isotoper

For små peptider er forskjellen minimal, men den blir mer betydelig for større proteiner. Massespektrometri måler vanligvis monoisotopiske masser for mindre molekyler og gjennomsnittlige masser for større.

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

Kalkulatoren tar hensyn til de standard N-terminal (NH₂-) og C-terminal (-COOH) gruppene ved å legge tilbake ett vannmolekyl (18.01528 Da) etter å ha trukket fra vannet som går tapt i peptidbindingdannelsen. Dette sikrer at den beregnede molekylvekten representerer det komplette proteinet med riktige terminalgrupper.

Kan jeg beregne molekylvekten til et protein med disulfidbindinger?

Ja, men denne kalkulatoren justerer ikke automatisk for disulfidbindinger. Hver disulfidbinding dannelse resulterer i tapet av to hydrogenatomer (2.01588 Da). For å ta hensyn til disulfidbindinger, trekk fra 2.01588 Da fra den beregnede molekvekten for hver disulfidbinding i proteinet ditt.

Hvordan forholder protein molekylvekt seg til protein størrelse?

Selv om molekylvekt korrelerer med protein størrelse, er forholdet ikke alltid enkelt. Faktorer som påvirker den fysiske størrelsen på et protein inkluderer:

• Aminosyresammensetning
• Sekundær- og tertiærstruktur
• Hydrasjonskjede
• Post-translasjonsmodifikasjoner
• Miljøforhold (pH, saltkonsentrasjon)

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

Referanser

1. Gasteiger E., Hoogland C., Gattiker A., Duvaud S., Wilkins M.R., Appel R.D., Bairoch A. (2005) Proteinidentifikasjon og analyseverktøy 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. utg.). W.H. Freeman and Company.

3. Steen, H., & Mann, M. (2004). ABC'ene (og XYZ'ene) av peptidsekvensering. 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. utg.). Wiley.

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

6. UniProt Consortium. (2021). UniProt: den universelle protein kunnskapsbasen 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 bioinformatikkressursportal. Nucleic Acids Research, 40(W1), W597-W603.

8. Kinter, M., & Sherman, N. E. (2005). Proteinsekvensering og identifikasjon ved bruk av tandem massespektrometri. Wiley-Interscience.

Prøv vår Protein molekylvektorkalkulator i dag for raskt og nøyaktig å bestemme molekylvekten til proteinsekvensene dine. Enten du planlegger eksperimenter, analyserer resultater eller lærer om proteinbiokjemi, gir dette verktøyet deg informasjonen du trenger på sekunder.