How to calculate Settlement Allocator in Indiana

Quick takeaways

• Indiana settlement allocation for class actions is typically handled through Indiana Trial Rule 23 (Ind. Trial R. 23), which substantially mirrors Federal Rule of Civil Procedure 23.
• No claim-type-specific “default allocator period” rule is provided in the materials you supplied, so you should treat the class-action period you define for settlement administration as the general default under Ind. Trial R. 23.
• DocketMath’s Settlement Allocator helps you calculate an allocation using:

  • the class period you’re applying,
  • each claimant’s individual qualifying facts, and
  • the settlement fund (and any applicable net distributable amount) you’re distributing.
• The output you usually need is an allocation amount per claimant (and/or a normalized allocator fraction) suitable for notice, claims administration, or exhibits.

Inputs you need

Before you open the Settlement Allocator tool, gather inputs in four buckets. This also prevents common allocator math errors (wrong period, wrong denominators, mixing counts and fractions).

1) Settlement distribution inputs

• Total settlement fund (or the amount allocated to the class pool you’re distributing)
• Administrative fee / holdback (if your settlement agreement applies one)
• Net distributable amount

  • If you need to compute it: net = total − fees − holdbacks

2) Class period inputs (Indiana / Ind. Trial R. 23 framework)

Ind. Trial R. 23 governs class actions and relates to class-action procedure in Indiana courts; per the provided materials, it substantially mirrors Fed. R. Civ. P. 23.

For allocator calculations, the key operational input is the eligibility period your settlement administration uses. You’ll need:

• Class period start date
• Class period end date
• Any event date logic that determines when eligibility begins/ends (for example, an exposure window, purchase date window, enrollment date window—whatever your settlement defines)

Pitfall to avoid: don’t assume there is a special “allocator period” rule in Indiana for every claim type. In the materials provided, no claim-type-specific sub-rule was found, so you should apply the general default period aligned with the settlement’s class-action administration under Ind. Trial R. 23.

3) Claimant-level qualifying inputs

For each claimant (or each class member record), collect the values DocketMath needs to compute a claimant’s weight.

Common examples include:

• Qualifying units during the class period

  • e.g., number of transactions, number of months of coverage, number of units purchased
• Qualifying dates

  • so the tool can determine how much of the class period the claimant spans
• Exclusions / disqualifiers

  • if your settlement administration defines them
• Any caps or floors your settlement agreement uses

  • e.g., maximum eligible amount or maximum eligible unit count

4) Normalization inputs (denominators)

To convert weights into allocation fractions, you need denominator logic:

• Total weight across all claimants

  • or the total eligible population weight, depending on your administration design
• Any minimum thresholds

  • e.g., discarding tiny or “de minimis” claims per your process
• Rounding policy

  • e.g., round to the nearest cent after allocation

How the calculation works

DocketMath’s Settlement Allocator typically uses a consistent workflow:

1. calculate an eligibility/weight per claimant for the Indiana class-action period,
2. sum weights for normalization (denominator),
3. distribute the net settlement fund proportionally.

Because the settlement agreement defines what counts as a “qualifying unit,” your job is to feed DocketMath the correct eligibility definitions—rather than inventing eligibility outside what the settlement describes in practice (and consistent with Ind. Trial R. 23 class-action administration).

Step 1: Determine the eligible class period (Indiana)

Using Ind. Trial R. 23 as the procedural framework, define the class period your settlement administration uses.

What you do in DocketMath:

• Set the class period start and class period end
• Configure date overlap logic (how DocketMath determines whether qualifying activity occurred “within the period”)

Impact on output:
If you widen the class period, claimant weights often increase (more qualifying events fall “in-window”). Narrowing the period typically reduces weights and changes everyone’s allocation fractions.

Step 2: Compute claimant weight inside the class period

For each claimant, DocketMath calculates a weight based on your settlement’s qualifying logic.

A typical proportional allocation pattern looks like:

• Claimant weight = (qualifying units within class period) × (any unit multiplier/cap rules)

Illustrative structure (not legal advice):

• If a claimant has 40 qualifying units and your admin allocates per unit:

  • weight = 40
• If you apply a cap:

  • weight = min(qualifying units, cap)

Impact on output:
Boundary/date-handling choices (inclusive vs. exclusive end dates, partial period treatment, event-date timing rules) can shift qualifying-unit counts and therefore change allocations.

Step 3: Normalize weights into allocation fractions

Once each claimant has a weight, normalize:

• Total weight = Σ(weightᵢ)
• Allocation fractionᵢ = weightᵢ / total weight

Impact on output:
Allocations are relative. Adding a claimant with a large weight reduces the fraction for everyone else because the denominator increases.

Step 4: Multiply by the net settlement fund

Finally:

• Allocation amountᵢ = allocation fractionᵢ × net settlement fund

If your settlement includes fees/holdbacks:

• use the net distributable amount so dollars match what’s actually distributed.

Impact on output:
Changing fees/holdbacks changes the absolute dollars but doesn’t change fractions (since fractions depend on weights, not the total dollars—unless your admin design ties dollars back into weighting).

Step 5: Apply rounding and threshold/true-up logic

DocketMath will output allocations according to its rounding approach. Ensure it aligns with how your settlement agreement expects distribution.

Two practical reminders:

• Rounding can cause the sum of individual allocations to differ slightly from the net distributable total.
• Many administrators use a true-up step to reconcile pennies (e.g., adjusting one claimant, distributing the remainder by a rule, or applying a last-step correction).

Common pitfalls

These issues frequently cause allocation errors when implementing an Indiana class-action settlement allocator:

1) Using the wrong eligibility dates

• Error: Using claim submission date instead of qualifying event date.
• Fix: Ensure DocketMath uses qualifying dates/events to determine class-period overlap.

2) Mixing “counts” and “money” as if they’re interchangeable

• Error: Treating a dollar amount as though it were “units,” or treating units as dollars.
• Fix: Choose what the weight measure represents (units, months, transactions, or a settlement-defined weight score) and keep it consistent end-to-end.

3) Assuming Indiana has a special claim-type-specific allocator period rule

Based on the provided jurisdiction framework, the materials point to general/default class-action governance under Ind. Trial R. 23 and do not identify claim-type-specific sub-rules for allocator period calculation.

• Fix: Use Ind. Trial R. 23 as the class-action procedural framework, then apply the settlement’s own eligibility definitions for allocator period and qualifying units.

4) Not normalizing by total weight

• Error: Computing allocation = weight × fund rather than allocation = (weight / total weight) × fund.
• Fix: Always calculate fractions using weightᵢ / Σ(weight).

5) Not reconciling rounding totals

• Error: Allocations sum to a different amount than the net distributable total.
• Fix: Use DocketMath outputs and apply (if required by your process) a true-up method consistent with your settlement administration instructions.

Sources and references

• Indiana Trial Rule 23 (Ind. Trial R. 23), Indiana Courts — Trial Procedure Rules
  https://www.in.gov/courts/rules/trial_proc/index.html#_Toc108079199

  • Jurisdiction note included in the brief: “Indiana Trial Rule 23 governs class actions and substantially mirrors Federal Rule of Civil Procedure 23.”

Next steps

1. Go to DocketMath Settlement Allocator.
2. Enter settlement amounts:

   • total settlement fund
   • fees/holdbacks (if applicable)
   • confirm the net distributable amount
3. Enter the class period that your settlement uses for eligibility:

   • start date
   • end date
   • any event-date rules for eligibility windows
4. Load claimant-level data required for qualifying-unit calculations:

   • qualifying unit counts within the period
   • qualifying dates and any exclusions/caps
5. Review outputs:

   • allocation fraction per claimant
   • allocation amount per claimant
   • sum totals vs. net distributable after rounding
6. If totals don’t reconcile:

   • re-check date overlap inputs
   • confirm normalization denominator logic
   • adjust rounding/true-up settings per your administration process

Checklist before finalizing:

• Class period start/end match the settlement administration period under the Ind. Trial R. 23 framework
• Weights are based on the correct qualifying units (not the wrong date field)
• Allocations use normalized fractions (weight / total weight)
• Final allocation totals match the net distributable amount after rounding/true-up

Related reading

• How to calculate Settlement Allocator in Ohio — Full how