How to calculate pain and suffering damages in South Carolina

Direct answer

In South Carolina, pain and suffering damages are handled as part of compensatory damages and are reduced (allocated) under the state comparative fault framework in S.C. Code Ann. § 15-38-15. If the plaintiff’s fault is high enough under the statute’s comparative allocation rules, recovery may be barred depending on the modeled fault percentages.

This guide explains how to calculate and allocate a pain-and-suffering damages amount in DocketMath using the South Carolina (US-SC) setup so your final “net” pain-and-suffering number reflects (1) the gross pain-and-suffering input you start with and (2) the South Carolina comparative fault adjustment applied by the calculator.

What you need to know

To model pain and suffering damages in US-SC in DocketMath, you mainly need two categories of inputs:

• The pain-and-suffering dollar amount you want to allocate (the “gross” figure before fault reduction)
• Fault percentages consistent with a comparative fault scenario

DocketMath’s damages-allocation calculator is designed for this exact workflow: it takes a damages component (like pain and suffering) and produces an allocated amount consistent with the jurisdiction you choose—here, South Carolina (US-SC) under S.C. Code Ann. § 15-38-15.

A quick practical way to think about it:

• If you enter the same gross pain-and-suffering number across scenarios, the allocated pain-and-suffering output should move downward as the plaintiff’s percentage of fault increases (because comparative allocation reduces the plaintiff’s recoverable portion).
• If your scenario pushes the plaintiff’s fault toward the comparative-fault bar threshold used by the workflow (see “Common pitfalls” for the exact modeling threshold value), DocketMath’s output may reflect a bar to recovery behavior under the statute’s comparative-allocation mechanism.

Fault input checklist (what you should have ready):

• ☐ Gross pain and suffering (single number; enter it as its own line item)
• ☐ Plaintiff fault % (0–100)
• ☐ Defendant fault % (or, if you have multiple defendants in your model, a set of defendant percentages that fit your scenario logic)

Step-by-step

Follow these steps in DocketMath using the /tools/damages-allocation workflow.

1) Open the right DocketMath tool

Start at the primary CTA: /tools/damages-allocation.

2) Set jurisdiction to South Carolina (US-SC)

In the tool’s jurisdiction settings:

• Select South Carolina (US-SC) so the allocation logic tracks S.C. Code Ann. § 15-38-15.

3) Enter pain and suffering as a dedicated damages line item

Add your damages component:

• Pain and suffering = [your gross dollar amount]

If you have other categories (e.g., medical expenses, wage loss), keep them as separate line items if your sheet has them. This makes the pain-and-suffering allocation easier to audit in the output.

4) Enter fault percentages consistent with the scenario

Provide:

• Plaintiff fault percentage
• Defendant fault percentage(s) (so that your model reflects the comparative allocation scenario you want to test)

Practical constraint for cleaner outputs:

• Keep the percentages coherent for the scenario you’re describing (for example, if the plaintiff is 20%, the remainder should be allocated to defendants as your scenario requires).

5) Run the allocation and review the pain-and-suffering result

After running:

• Locate the output for the allocated “Pain and suffering” line item
• Compare it to your gross entry to confirm the adjustment direction matches your expectations for the entered fault

Also confirm that the calculator is using:

• The US-SC comparative allocation rules under S.C. Code Ann. § 15-38-15
• The scenario you entered (particularly the plaintiff fault percentage and corresponding defendant percentage(s))

6) Iterate with a small set of “sensitivity” scenarios

To understand how the model behaves, run at least three scenarios with:

• Same gross pain-and-suffering input
• Different fault allocations

For example:

• Low plaintiff fault
• Moderate plaintiff fault
• High plaintiff fault (near the modeling bar threshold)

This is especially useful when you’re evaluating settlement posture or testing how allocation could affect exposure.

Key statutes and citations

• S.C. Code Ann. § 15-38-15 — South Carolina’s comparative fault allocation framework that governs how damages are reduced according to fault, including how the plaintiff’s recoverable portion is adjusted.

• Nelson v. Concrete Supply Co., 303 S.C. 243, 399 S.E.2d 783 (1991) — South Carolina precedent that is sometimes cited in practice in connection with negligence and liability/damages issues intersecting comparative fault analysis.

(As always, when applying the law to a real case, confirm interpretation with qualified counsel.)

Common pitfalls

• Entering pain and suffering as part of a combined total
  If you bundle pain and suffering with other damages, you’ll lose the ability to clearly see how the comparative allocation impacted that specific component.

• Using incoherent fault percentages
  If the plaintiff percentage and defendant remainder don’t reflect a consistent scenario, the allocated output may be misleading. In DocketMath, make sure the entered fault inputs represent the story you’re modeling.

• Forgetting to set the calculator to South Carolina (US-SC)
  If you leave the tool in the wrong jurisdiction, you could apply the wrong allocation logic and generate an output that doesn’t correspond to S.C. Code Ann. § 15-38-15.

• Assuming comparative allocation won’t affect pain and suffering
  Under the South Carolina comparative fault framework used by S.C. Code Ann. § 15-38-15, allocation can reduce the plaintiff’s recoverable share. DocketMath’s purpose here is to apply that reduction to the damages component you enter.

• Misunderstanding the bar threshold behavior in the model
  The workflow uses a comparative-fault bar threshold percent of 51. If your plaintiff fault percentage is at or above that modeled threshold, DocketMath may reflect barred recovery behavior consistent with the allocation mechanism used in this jurisdiction-aware workflow.

Run the numbers

Use the following quick process to validate that the DocketMath outputs look reasonable in US-SC.

1) Build a simple test matrix

Hold constant the gross pain and suffering input (e.g., $X), and vary only plaintiff fault:

2) Sanity-check the direction of change

After each run:

• If plaintiff fault increases, the allocated “Pain and suffering” output should generally decrease.
• As plaintiff fault approaches the modeling bar threshold (51), the model’s output may reflect a more extreme reduction or bar behavior.

3) Do a before/after audit per run

Keep a simple checklist:

• ☐ Pain and suffering entered as its own line item
• ☐ Jurisdiction set to South Carolina (US-SC)
• ☐ Fault percentages coherent for the scenario
• ☐ Output shows an allocated pain-and-suffering figure that changed with fault

Related reading

• How to calculate Damages Allocation in Philippines — Full how-to guide with jurisdiction-specific rules
• Worked example: Damages Allocation in Philippines — Worked example with real statute citations
• Inputs you need for Damages Allocation in Philippines — Input checklist with sourcing guidance