How to calculate Settlement Allocator in Ohio

Quick takeaways

• Ohio’s settlement allocation framework for class/representative matters is governed procedurally by Ohio Civ. R. 23, but Ohio Civ. R. 23 does not contain a single “Settlement Allocator formula” you can plug values into.
• A “Settlement Allocator” calculation usually means translating the settlement fund into individual recoveries using plan-approved allocation factors (for example, damages assumptions, claim value scores, or evidence tiers).
• DocketMath’s Settlement Allocator helps you compute those recoveries consistently once you’ve defined the allocation basis used in your Ohio matter.
• This guide focuses on the general/default approach under Civil Rule 23 and clearly notes that no claim-type-specific sub-rule was found in the cited Civil Procedure materials.
• Not legal advice: this is an operational walkthrough of a settlement allocation workflow and must be aligned to the specific settlement agreement and any court-approved plan.

Inputs you need

Before you open DocketMath’s Settlement Allocator calculator, gather the inputs that control your allocations. The key is to document where each number comes from, because under Ohio Civ. R. 23 the fairness/adequacy of the allocation method typically depends on how the settlement plan treats class members.

Tool CTA: you can use the workflow at /tools/settlement-allocator.

A. Settlement-level inputs

Collect the settlement figures and the rules for what is actually “allocable”:

• Total settlement amount (S) — the fund you intend to distribute.
• Fees and costs handling approach

  • Are fees/costs netted out before allocation (reducing the pool)?
  • Or are they handled separately from the allocation pool?
• Reserve / holdback amount (R) — if the plan withholds a portion for administration, contingencies, or later claims.
• Claims process structure

  • Example: allocations may differ between claim-submitters and non-submitters, or between approved vs. rejected claims.

B. Member-level inputs (per class member or per claim unit)

Create a row per class member (or claim unit) so results are reproducible:

• Damages weight / allocation factor (wᵢ)

  • Often a “claim value” score, expected damages measure, or proportional weight tied to the settlement plan.
• Eligibility flag

  • Example: “Eligible if required claim information is complete and meets minimum thresholds.”
• Individual cap / floor parameters (if your plan includes them)
• Evidence category / tier input (only if the plan uses tiered factors)

C. Allocation-method settings (what DocketMath needs to model your plan)

In DocketMath, you’ll define the allocation basis that matches how the settlement plan assigns values. Common models include:

• Proportional allocation

  • Allocate based on each member’s weight relative to the total eligible weight.
• Tiered proportional allocation

  • Allocate different portions of the fund to tiers (e.g., different evidence strength categories).
• Capped proportional allocation

  • Allocate proportionally, enforce caps, then redistribute any excess according to the plan.

Quick checklist

• I have the total settlement amount (S)
• I know whether the allocator should treat the pool as gross or net (after fees/costs)
• I have the per-member weights (wᵢ) from the plan’s allocation basis
• I have any tier/cap rules the plan requires
• I have the eligibility logic that determines who is included in the denominator

Ohio rule anchor (what Rule 23 does—and doesn’t do)

Ohio’s Civil Rule 23 provides the procedural framework for class actions, including how settlement fits within Rule 23’s requirements. The cited Civil Procedure rules document is your procedural reference point for this guide: Ohio Civ. R. 23 (from the Ohio Supreme Court’s Civil Procedure rules compilation).

Important clarity (per your note): no claim-type-specific sub-rule was found in the provided Civil Procedure material for this topic. So this post describes the general/default Rule 23 approach and emphasizes implementing the settlement’s specific allocation plan mechanics, rather than relying on a claim-category-specific allocator rule.

How the calculation works

DocketMath’s Settlement Allocator translates your defined allocation method into member-level recoveries. Conceptually, the workflow is:

1. Calculate the allocable pool
2. Compute each member’s share factor
3. Apply caps/tiers/eligibility rules (if present)
4. Output estimated allocation amounts

Step 1: Determine the allocable pool (P)

Let:

• S = total settlement amount
• F = fees and costs deducted before allocation (if applicable)
• R = reserve/holdback (if applicable)

Then the allocable pool P often becomes:

• P = S − F − R

If your settlement agreement treats allocations as gross, and fees/costs are handled separately, then P may equal S for the allocator step.

In DocketMath terms: select the setting that matches whether your allocator is modeling pre-allocation deductions for fees/costs.

Step 2: Choose the allocation basis (“allocator” math)

The most common model is proportional allocation.

Define:

• wᵢ = weight for member i
• W = Σ wᵢ = total weight across eligible members

Then:

• allocationᵢ = P × (wᵢ / W)

Eligibility effect (denominator control)

Eligibility rules usually change the denominator W. For example, if member i is excluded (ineligible claim, missing required documentation, etc.), you typically remove their weight from W, which increases allocations for those remaining eligible members.

DocketMath should reflect this by filtering based on eligibility before summing W.

Step 3: Apply tiering or caps (if your plan includes them)

A) Tiered allocation

If the plan assigns different allocation pools by tier:

• P₁, P₂, … with tier weights W₁, W₂, …

Then for a member i in tier t:

• allocationᵢ in tier t = P_t × (wᵢ / W_t)

In DocketMath, you’d enter tier parameters and assign each member a tier consistent with the plan.

B) Capped proportional allocation

If the plan imposes a maximum recovery capᵢ:

1. Compute uncapped allocation:

   • aᵢ = P × (wᵢ / W)
2. Apply the cap:

   • aᵢ' = min(aᵢ, capᵢ)

If the plan requires redistribution of excess created by caps, do a second pass:

• Leftover pool = P − Σ aᵢ'
• Redistribute leftover among the appropriate set of members (commonly the uncapped members) using the plan’s specified method.

Make sure your DocketMath configuration matches whether redistribution is required and how the redistribution denominator is defined.

Step 4: Tie the calculation back to Rule 23 (general/default approach)

Ohio Civil Rule 23 governs how settlement is addressed within the class action framework. This guide does not identify a claim-type-specific allocator sub-rule in the provided Civil Procedure material. So treat timing and category mechanics as general/default Rule 23 guidance and focus on implementing the settlement plan’s allocation terms.

Common pitfalls

1) Gross vs. net pool mistakes (fees/costs and holdbacks)

If you allocate from the wrong pool, everything moves.

• Confirm whether DocketMath should use P = S − F − R or P = S for your settlement’s allocator step.

2) Denominator drift from eligibility logic

Even if weights are identical, excluding different members changes W and reallocates value.

• Ensure your eligibility filter matches the plan (not an internal assumption).

3) Tier misassignment

Tiering errors happen when categories come from different source fields or inconsistent mapping.

• Normalize tier inputs before running the allocator.

4) Cap handling without the required redistribution method

Caps typically create a leftover amount.

• Confirm whether the plan redistributes excess and, if so, to whom and using what weight basis.

5) Assuming Rule 23 provides a plug-and-play allocator formula

As noted, Ohio Civ. R. 23 does not supply a single settlement allocator equation. The calculation needs to follow the settlement allocation plan and the evidence/weighting approach it approves.

Sources and references

• Ohio Civ. R. 23 (Civil Procedure Rules—class actions; settlement within the Rule 23 framework)
  Source: Ohio Supreme Court, Civil Procedure Rules (CivilProcedure.pdf) — https://www.supremecourt.ohio.gov/docs/LegalResources/Rules/civil/CivilProcedure.pdf

Next steps

1. Open /tools/settlement-allocator in DocketMath.
2. Enter settlement inputs:

   • S (total settlement)
   • Fees/costs handling (pre- vs. post-allocation)
   • R (reserve/holdback, if any)
3. Load your member-level data:

   • verify each wᵢ (weight) source
   • verify eligibility fields and confirm how they affect W
4. Select the allocation mode to match the settlement plan:

   • proportional, tiered proportional, or capped proportional
5. Run validation checks on a small subset:

   • do allocations sum to the intended pool P?
   • do capped members match the cap logic and any redistribution rules?
6. Export results and maintain an audit trail (inputs, mapping logic, and version of the allocator configuration).

Related reading

• [How to calculate Settlement Allocator in Philippines]