0
# MODFLOW 2005 Models and Packages
1

2
This module provides comprehensive support for MODFLOW-2005, MODFLOW-NWT, MODFLOW-USG, and MODFLOW-2000 with extensive package coverage including flow, boundary conditions, and solvers. These are the legacy MODFLOW versions that remain widely used and supported, offering proven reliability and compatibility with existing workflows.
3

4
## Core Model Class
5

6
### Modflow
7

8
The main MODFLOW 2005 model class that serves as a container for packages and manages model execution.
9

10
```python { .api }
11
class Modflow:
12
    """MODFLOW 2005 model container and execution manager"""
13
    def __init__(
14
        self,
15
        modelname: str = 'modflowtest',
16
        namefile_ext: str = 'nam',
17
        version: str = 'mf2005',
18
        exe_name: str = 'mf2005',
19
        structured: bool = True,
20
        listunit: int = 2,
21
        model_ws: str = '.',
22
        external_path: str = None,
23
        verbose: bool = False,
24
        **kwargs
25
    ): ...
26
    
27
    def write_input(
28
        self,
29
        SelPackList: list = None,
30
        check: bool = True
31
    ) -> None:
32
        """Write MODFLOW input files"""
33
        ...
34
    
35
    def run_model(
36
        self,
37
        silent: bool = False,
38
        pause: bool = False,
39
        report: bool = False,
40
        normal_msg: str = 'normal termination'
41
    ) -> tuple[bool, list[str]]:
42
        """Run the MODFLOW model and return success status and output"""
43
        ...
44
    
45
    def load(
46
        cls,
47
        f: str,
48
        version: str = 'mf2005',
49
        exe_name: str = None,
50
        verbose: bool = False,
51
        model_ws: str = '.',
52
        load_only: list = None,
53
        forgive: bool = False,
54
        check: bool = True
55
    ) -> 'Modflow':
56
        """Load existing MODFLOW model from files"""
57
        ...
58
    
59
    def add_package(self, p: object) -> None:
60
        """Add package to model"""
61
        ...
62
    
63
    def remove_package(self, pname: str) -> None:
64
        """Remove package from model"""
65
        ...
66
    
67
    def get_package(self, name: str) -> object:
68
        """Get package by name"""
69
        ...
70
    
71
    def get_package_list(self, ftype: str = None) -> list[str]:
72
        """Get list of packages"""
73
        ...
74
    
75
    def set_model_units(self, iunit: dict = None) -> None:
76
        """Set model unit numbers"""
77
        ...
78
    
79
    @property
80
    def modelgrid(self) -> object:
81
        """Model grid object"""
82
        ...
83
    
84
    @property
85
    def packages(self) -> list[object]:
86
        """List of model packages"""
87
        ...
88
    
89
    @property
90
    def packagelist(self) -> list[str]:
91
        """List of package names"""
92
        ...
93
```
94

95
## Core Packages
96

97
### ModflowBas
98

99
Basic package that defines model structure and provides fundamental model information.
100

101
```python { .api }
102
class ModflowBas:
103
    """MODFLOW basic package"""
104
    def __init__(
105
        self,
106
        model: Modflow,
107
        ibound: ArrayData = 1,
108
        strt: ArrayData = 1.0,
109
        ifrefm: bool = True,
110
        ixsec: bool = False,
111
        ichflg: bool = False,
112
        stoper: float = None,
113
        hnoflo: float = 999.0,
114
        extension: str = 'bas',
115
        unitnumber: int = None,
116
        filenames: str = None,
117
        **kwargs
118
    ): ...
119
```
120

121
**Parameters:**
122
- `ibound` (ArrayData): Boundary type array (>0: active, 0: inactive, <0: constant head)
123
- `strt` (ArrayData): Starting head values
124
- `hnoflo` (float): Head value for inactive cells
125
- `ifrefm` (bool): Whether input is free format
126

127
### ModflowDis
128

129
Discretization package that defines the spatial and temporal framework.
130

131
```python { .api }
132
class ModflowDis:
133
    """MODFLOW discretization package"""
134
    def __init__(
135
        self,
136
        model: Modflow,
137
        nlay: int = 1,
138
        nrow: int = 2,
139
        ncol: int = 2,
140
        nper: int = 1,
141
        delr: ArrayData = 1.0,
142
        delc: ArrayData = 1.0,
143
        laycbd: ArrayData = 0,
144
        top: ArrayData = 1.0,
145
        botm: ArrayData = 0.0,
146
        perlen: ArrayData = 1.0,
147
        nstp: ArrayData = 1,
148
        tsmult: ArrayData = 1.0,
149
        steady: ArrayData = True,
150
        itmuni: int = 4,
151
        lenuni: int = 2,
152
        extension: str = 'dis',
153
        unitnumber: int = None,
154
        filenames: str = None,
155
        **kwargs
156
    ): ...
157
```
158

159
**Parameters:**
160
- `nlay` (int): Number of layers
161
- `nrow` (int): Number of rows
162
- `ncol` (int): Number of columns
163
- `nper` (int): Number of stress periods
164
- `delr` (ArrayData): Column spacing
165
- `delc` (ArrayData): Row spacing
166
- `top` (ArrayData): Top elevation of layer 1
167
- `botm` (ArrayData): Bottom elevation of layers
168
- `perlen` (ArrayData): Length of stress periods
169
- `nstp` (ArrayData): Number of time steps per stress period
170
- `tsmult` (ArrayData): Time step multiplier
171

172
### ModflowOc
173

174
Output control package that manages model output options.
175

176
```python { .api }
177
class ModflowOc:
178
    """MODFLOW output control package"""
179
    def __init__(
180
        self,
181
        model: Modflow,
182
        ihedfm: int = 0,
183
        iddnfm: int = 0,
184
        chedfm: str = None,
185
        cddnfm: str = None,
186
        cboufm: str = None,
187
        compact: bool = True,
188
        stress_period_data: dict = None,
189
        extension: str = 'oc',
190
        unitnumber: int = None,
191
        filenames: str = None,
192
        **kwargs
193
    ): ...
194
```
195

196
## Flow Packages
197

198
### ModflowLpf
199

200
Layer property flow package for confined and unconfined aquifer properties.
201

202
```python { .api }
203
class ModflowLpf:
204
    """MODFLOW layer property flow package"""
205
    def __init__(
206
        self,
207
        model: Modflow,
208
        laytyp: ArrayData = 0,
209
        layavg: ArrayData = 0,
210
        chani: ArrayData = 1.0,
211
        layvka: ArrayData = 0,
212
        laywet: ArrayData = 0,
213
        ipakcb: int = None,
214
        hdry: float = -1e30,
215
        iwdflg: int = 0,
216
        wetfct: float = 0.1,
217
        iwetit: int = 1,
218
        ihdwet: int = 0,
219
        hk: ArrayData = 1.0,
220
        hani: ArrayData = 1.0,
221
        vka: ArrayData = 1e-6,
222
        ss: ArrayData = 1e-5,
223
        sy: ArrayData = 0.15,
224
        vkcb: ArrayData = 0.0,
225
        wetdry: ArrayData = -0.01,
226
        storagecoefficient: bool = False,
227
        constantcv: bool = False,
228
        thickstrt: bool = False,
229
        nocvcorrection: bool = False,
230
        novfc: bool = False,
231
        extension: str = 'lpf',
232
        unitnumber: int = None,
233
        filenames: str = None,
234
        **kwargs
235
    ): ...
236
```
237

238
**Parameters:**
239
- `laytyp` (ArrayData): Layer type (0: confined, >0: convertible)
240
- `hk` (ArrayData): Horizontal hydraulic conductivity
241
- `vka` (ArrayData): Vertical hydraulic conductivity or anisotropy ratio
242
- `ss` (ArrayData): Specific storage
243
- `sy` (ArrayData): Specific yield
244
- `hdry` (float): Head assigned to dry cells
245

246
### ModflowBcf
247

248
Block-centered flow package for regular flow properties.
249

250
```python { .api }
251
class ModflowBcf:
252
    """MODFLOW block-centered flow package"""
253
    def __init__(
254
        self,
255
        model: Modflow,
256
        ipakcb: int = None,
257
        intercellt: int = 0,
258
        laycon: ArrayData = 3,
259
        trpy: ArrayData = 1.0,
260
        hdry: float = -1e30,
261
        iwdflg: int = 0,
262
        wetfct: float = 0.1,
263
        iwetit: int = 1,
264
        ihdwet: int = 0,
265
        tran: ArrayData = 1.0,
266
        hy: ArrayData = 1.0,
267
        vcont: ArrayData = 1.0,
268
        sf1: ArrayData = 1e-5,
269
        sf2: ArrayData = 0.15,
270
        wetdry: ArrayData = -0.01,
271
        extension: str = 'bcf',
272
        unitnumber: int = None,
273
        filenames: str = None,
274
        **kwargs
275
    ): ...
276
```
277

278
### ModflowUpw
279

280
Upstream weighting package for improved numerical stability.
281

282
```python { .api }
283
class ModflowUpw:
284
    """MODFLOW upstream weighting package"""
285
    def __init__(
286
        self,
287
        model: Modflow,
288
        laytyp: ArrayData = 0,
289
        layavg: ArrayData = 0,
290
        chani: ArrayData = 1.0,
291
        layvka: ArrayData = 0,
292
        laywet: ArrayData = 0,
293
        ipakcb: int = None,
294
        hdry: float = -1e30,
295
        npupw: int = 1,
296
        iphdry: int = 0,
297
        hk: ArrayData = 1.0,
298
        hani: ArrayData = 1.0,
299
        vka: ArrayData = 1e-6,
300
        ss: ArrayData = 1e-5,
301
        sy: ArrayData = 0.15,
302
        vkcb: ArrayData = 0.0,
303
        wetdry: ArrayData = -0.01,
304
        extension: str = 'upw',
305
        unitnumber: int = None,
306
        filenames: str = None,
307
        **kwargs
308
    ): ...
309
```
310

311
### ModflowHfb
312

313
Horizontal flow barriers package for flow impedance features.
314

315
```python { .api }
316
class ModflowHfb:
317
    """MODFLOW horizontal flow barriers package"""
318
    def __init__(
319
        self,
320
        model: Modflow,
321
        nhfbnp: int = 0,
322
        mxfb: int = 0,
323
        nhfbx1: int = 0,
324
        nhfbx2: int = 0,
325
        hfb_data: list = None,
326
        nactp: int = 0,
327
        nactcbhfb: int = 0,
328
        no_print: bool = False,
329
        options: list = None,
330
        extension: str = 'hfb',
331
        unitnumber: int = None,
332
        filenames: str = None,
333
        **kwargs
334
    ): ...
335
```
336

337
## Boundary Condition Packages
338

339
### ModflowWel
340

341
Well package for pumping and injection wells.
342

343
```python { .api }
344
class ModflowWel:
345
    """MODFLOW well package"""
346
    def __init__(
347
        self,
348
        model: Modflow,
349
        ipakcb: int = None,
350
        stress_period_data: StressPeriodData = None,
351
        dtype: np.dtype = None,
352
        extension: str = 'wel',
353
        unitnumber: int = None,
354
        filenames: str = None,
355
        options: list = None,
356
        binary: bool = False,
357
        **kwargs
358
    ): ...
359
```
360

361
**Parameters:**
362
- `stress_period_data` (StressPeriodData): Well data by stress period
363
  - Format: {period: [[layer, row, col, flux], ...]}
364

365
### ModflowRch
366

367
Distributed recharge package.
368

369
```python { .api }
370
class ModflowRch:
371
    """MODFLOW recharge package"""
372
    def __init__(
373
        self,
374
        model: Modflow,
375
        nrchop: int = 3,
376
        ipakcb: int = None,
377
        rech: ArrayData = 0.001,
378
        irch: ArrayData = 0,
379
        extension: str = 'rch',
380
        unitnumber: int = None,
381
        filenames: str = None,
382
        **kwargs
383
    ): ...
384
```
385

386
**Parameters:**
387
- `nrchop` (int): Recharge option (1: layer 1 only, 2: specified layer, 3: highest active)
388
- `rech` (ArrayData): Recharge rates
389
- `irch` (ArrayData): Layer for recharge application
390

391
### ModflowEvt
392

393
Evapotranspiration package.
394

395
```python { .api }
396
class ModflowEvt:
397
    """MODFLOW evapotranspiration package"""
398
    def __init__(
399
        self,
400
        model: Modflow,
401
        nevtop: int = 3,
402
        ipakcb: int = None,
403
        surf: ArrayData = 0.0,
404
        evtr: ArrayData = 0.0004,
405
        exdp: ArrayData = 1.0,
406
        ievt: ArrayData = 0,
407
        extension: str = 'evt',
408
        unitnumber: int = None,
409
        filenames: str = None,
410
        **kwargs
411
    ): ...
412
```
413

414
**Parameters:**
415
- `nevtop` (int): ET option (1: layer 1 only, 2: specified layer, 3: highest active)
416
- `surf` (ArrayData): ET surface elevation
417
- `evtr` (ArrayData): Maximum ET rate
418
- `exdp` (ArrayData): Extinction depth
419

420
### ModflowGhb
421

422
General head boundary package.
423

424
```python { .api }
425
class ModflowGhb:
426
    """MODFLOW general head boundary package"""
427
    def __init__(
428
        self,
429
        model: Modflow,
430
        ipakcb: int = None,
431
        stress_period_data: StressPeriodData = None,
432
        dtype: np.dtype = None,
433
        no_print: bool = False,
434
        options: list = None,
435
        extension: str = 'ghb',
436
        unitnumber: int = None,
437
        filenames: str = None,
438
        binary: bool = False,
439
        **kwargs
440
    ): ...
441
```
442

443
**Parameters:**
444
- `stress_period_data` (StressPeriodData): GHB data by stress period
445
  - Format: {period: [[layer, row, col, stage, conductance], ...]}
446

447
### ModflowRiv
448

449
River package for river-aquifer interaction.
450

451
```python { .api }
452
class ModflowRiv:
453
    """MODFLOW river package"""
454
    def __init__(
455
        self,
456
        model: Modflow,
457
        ipakcb: int = None,
458
        stress_period_data: StressPeriodData = None,
459
        dtype: np.dtype = None,
460
        extension: str = 'riv',
461
        unitnumber: int = None,
462
        filenames: str = None,
463
        options: list = None,
464
        binary: bool = False,
465
        **kwargs
466
    ): ...
467
```
468

469
**Parameters:**
470
- `stress_period_data` (StressPeriodData): River data by stress period
471
  - Format: {period: [[layer, row, col, stage, conductance, bottom], ...]}
472

473
### ModflowDrn
474

475
Drain package for drainage features.
476

477
```python { .api }
478
class ModflowDrn:
479
    """MODFLOW drain package"""
480
    def __init__(
481
        self,
482
        model: Modflow,
483
        ipakcb: int = None,
484
        stress_period_data: StressPeriodData = None,
485
        dtype: np.dtype = None,
486
        extension: str = 'drn',
487
        unitnumber: int = None,
488
        filenames: str = None,
489
        options: list = None,
490
        binary: bool = False,
491
        **kwargs
492
    ): ...
493
```
494

495
### ModflowChd
496

497
Constant head boundary package.
498

499
```python { .api }
500
class ModflowChd:
501
    """MODFLOW constant head package"""
502
    def __init__(
503
        self,
504
        model: Modflow,
505
        stress_period_data: StressPeriodData = None,
506
        dtype: np.dtype = None,
507
        extension: str = 'chd',
508
        unitnumber: int = None,
509
        filenames: str = None,
510
        options: list = None,
511
        **kwargs
512
    ): ...
513
```
514

515
## Advanced Packages
516

517
### ModflowLak
518

519
Lake package for lake-aquifer interaction.
520

521
```python { .api }
522
class ModflowLak:
523
    """MODFLOW lake package"""
524
    def __init__(
525
        self,
526
        model: Modflow,
527
        nlakes: int = 1,
528
        ipakcb: int = None,
529
        theta: float = -1.0,
530
        nssitr: int = 0,
531
        sscncr: float = 0.0,
532
        surfdepth: float = 0.0,
533
        stages: ArrayData = 1.0,
534
        stage_range: ArrayData = None,
535
        lakarr: ArrayData = None,
536
        bdlknc: ArrayData = None,
537
        sill_data: dict = None,
538
        flux_data: dict = None,
539
        extension: str = 'lak',
540
        unitnumber: int = None,
541
        filenames: str = None,
542
        **kwargs
543
    ): ...
544
```
545

546
### ModflowSfr2
547

548
Streamflow routing package for stream networks.
549

550
```python { .api }
551
class ModflowSfr2:
552
    """MODFLOW streamflow routing package"""
553
    def __init__(
554
        self,
555
        model: Modflow,
556
        nstrm: int = 0,
557
        nss: int = 0,
558
        const: float = 86400.0,
559
        dleak: float = 0.0001,
560
        ipakcb: int = None,
561
        istcb2: int = None,
562
        isfropt: int = 1,
563
        nstrail: int = 10,
564
        isuzn: int = 1,
565
        nsfrsets: int = 30,
566
        irtflg: int = 1,
567
        numtim: int = 2,
568
        weight: float = 0.75,
569
        flwtol: float = 0.0001,
570
        reach_data: np.recarray = None,
571
        segment_data: dict = None,
572
        channel_geometry_data: dict = None,
573
        channel_flow_data: dict = None,
574
        dataset_5: dict = None,
575
        reachinput: bool = False,
576
        transroute: bool = False,
577
        tabfiles: bool = False,
578
        tabfiles_dict: dict = None,
579
        extension: str = 'sfr',
580
        unitnumber: int = None,
581
        filenames: str = None,
582
        **kwargs
583
    ): ...
584
```
585

586
### ModflowUzf1
587

588
Unsaturated zone flow package.
589

590
```python { .api }
591
class ModflowUzf1:
592
    """MODFLOW unsaturated zone flow package"""
593
    def __init__(
594
        self,
595
        model: Modflow,
596
        nuztop: int = 1,
597
        iuzfopt: int = 0,
598
        irunflg: int = 0,
599
        ietflg: int = 0,
600
        ipakcb: int = None,
601
        iuzfcb2: int = None,
602
        ntrail2: int = 10,
603
        nsets2: int = 20,
604
        nuzgag: int = 0,
605
        surfdep: float = 1.0,
606
        iuzfbnd: ArrayData = 1,
607
        irunbnd: ArrayData = 0,
608
        vks: ArrayData = 1e-6,
609
        eps: ArrayData = 3.5,
610
        thts: ArrayData = 0.35,
611
        thtr: ArrayData = 0.15,
612
        thti: ArrayData = 0.20,
613
        row_col_iftunit_iuzopt: list = None,
614
        extension: str = 'uzf',
615
        unitnumber: int = None,
616
        filenames: str = None,
617
        **kwargs
618
    ): ...
619
```
620

621
### ModflowSub
622

623
Subsidence package for land subsidence modeling.
624

625
```python { .api }
626
class ModflowSub:
627
    """MODFLOW subsidence package"""
628
    def __init__(
629
        self,
630
        model: Modflow,
631
        ipakcb: int = None,
632
        isuboc: int = 0,
633
        acc: float = 1e-5,
634
        itmin: int = 5,
635
        idsave: int = None,
636
        idrest: int = None,
637
        nndb: int = 1,
638
        ndb: int = 1,
639
        nmz: int = 1,
640
        nn: int = 20,
641
        ac1: float = 0.0,
642
        ac2: float = 1.0,
643
        itmin_sub: int = 5,
644
        ln: ArrayData = 0,
645
        rnb: ArrayData = 1.0,
646
        hc: ArrayData = 1.0,
647
        sfe: ArrayData = 1e-4,
648
        sfv: ArrayData = 1e-3,
649
        com: ArrayData = 1e-3,
650
        dp: list = None,
651
        dz: list = None,
652
        dhc: list = None,
653
        dcom: list = None,
654
        dz_mult: list = None,
655
        ids15: list = None,
656
        ids16: list = None,
657
        extension: str = 'sub',
658
        unitnumber: int = None,
659
        filenames: str = None,
660
        **kwargs
661
    ): ...
662
```
663

664
### ModflowSwi2
665

666
Seawater intrusion package for variable density flow.
667

668
```python { .api }
669
class ModflowSwi2:
670
    """MODFLOW seawater intrusion package"""
671
    def __init__(
672
        self,
673
        model: Modflow,
674
        nsrf: int = 1,
675
        istrat: int = 1,
676
        nobs: int = 0,
677
        iswizt: int = None,
678
        ipakcb: int = None,
679
        iswibd: int = 0,
680
        ihcofadd: int = 0,
681
        izcfl: int = 0,
682
        izcfm: int = 0,
683
        iglfl: int = 0,
684
        iglfm: int = 0,
685
        toeslope: float = 0.05,
686
        tipslope: float = 0.05,
687
        alpha: float = None,
688
        beta: float = 0.1,
689
        nadptmx: int = 1,
690
        nadptmn: int = 1,
691
        adptfct: float = 1.0,
692
        nu: ArrayData = 0.025,
693
        zeta: ArrayData = None,
694
        ssz: ArrayData = 0.25,
695
        isource: ArrayData = 0,
696
        obsnam: list = None,
697
        obslrc: list = None,
698
        extension: str = 'swi2',
699
        unitnumber: int = None,
700
        filenames: str = None,
701
        **kwargs
702
    ): ...
703
```
704

705
## Solver Packages
706

707
### ModflowPcg
708

709
Preconditioned conjugate gradient solver.
710

711
```python { .api }
712
class ModflowPcg:
713
    """MODFLOW preconditioned conjugate gradient solver"""
714
    def __init__(
715
        self,
716
        model: Modflow,
717
        mxiter: int = 50,
718
        iter1: int = 30,
719
        npcond: int = 1,
720
        hclose: float = 1e-5,
721
        rclose: float = 1e-5,
722
        relax: float = 1.0,
723
        nbpol: int = 0,
724
        iprpcg: int = 0,
725
        mutpcg: int = 3,
726
        damp: float = 1.0,
727
        dampt: float = 1.0,
728
        ihcofadd: int = 0,
729
        extension: str = 'pcg',
730
        unitnumber: int = None,
731
        filenames: str = None,
732
        **kwargs
733
    ): ...
734
```
735

736
### ModflowSip
737

738
Strongly implicit procedure solver.
739

740
```python { .api }
741
class ModflowSip:
742
    """MODFLOW strongly implicit procedure solver"""
743
    def __init__(
744
        self,
745
        model: Modflow,
746
        mxiter: int = 200,
747
        nparm: int = 5,
748
        accl: float = 1.0,
749
        hclose: float = 1e-5,
750
        ipcalc: int = 1,
751
        wseed: float = 0.0,
752
        iprsip: int = 0,
753
        extension: str = 'sip',
754
        unitnumber: int = None,
755
        filenames: str = None,
756
        **kwargs
757
    ): ...
758
```
759

760
### ModflowDe4
761

762
Direct solver for small problems.
763

764
```python { .api }
765
class ModflowDe4:
766
    """MODFLOW direct solver"""
767
    def __init__(
768
        self,
769
        model: Modflow,
770
        itmx: int = 50,
771
        mxup: int = 0,
772
        mxlow: int = 0,
773
        mxbw: int = 0,
774
        ifreq: int = 3,
775
        mutd4: int = 0,
776
        accl: float = 1.0,
777
        hclose: float = 1e-5,
778
        iprd4: int = 1,
779
        extension: str = 'de4',
780
        unitnumber: int = None,
781
        filenames: str = None,
782
        **kwargs
783
    ): ...
784
```
785

786
### ModflowNwt
787

788
Newton solver for improved convergence.
789

790
```python { .api }
791
class ModflowNwt:
792
    """MODFLOW Newton solver"""
793
    def __init__(
794
        self,
795
        model: Modflow,
796
        headtol: float = 0.01,
797
        fluxtol: float = 500.0,
798
        maxiterout: int = 100,
799
        thickfact: float = 1e-5,
800
        linmeth: int = 1,
801
        iprnwt: int = 0,
802
        ibotav: int = 0,
803
        options: str = 'COMPLEX',
804
        Continue: bool = False,
805
        dbdtheta: float = 0.4,
806
        dbdkappa: float = 1e-5,
807
        dbdgamma: float = 0.0,
808
        momfact: float = 0.1,
809
        backflag: int = 1,
810
        maxbackiter: int = 50,
811
        backtol: float = 1.1,
812
        backreduce: float = 0.7,
813
        maxitinner: int = 50,
814
        ilumethod: int = 2,
815
        levfill: int = 5,
816
        stoptol: float = 1e-10,
817
        msdr: int = 15,
818
        iacl: int = 2,
819
        norder: int = 1,
820
        level: int = 5,
821
        north: int = 7,
822
        iredsys: int = 0,
823
        rrctols: float = 0.0,
824
        idroptol: int = 1,
825
        epsrn: float = 1e-4,
826
        hclosexmd: float = 1e-4,
827
        mxiterxmd: int = 50,
828
        extension: str = 'nwt',
829
        unitnumber: int = None,
830
        filenames: str = None,
831
        **kwargs
832
    ): ...
833
```
834

835
### ModflowGmg
836

837
Geometric multigrid solver.
838

839
```python { .api }
840
class ModflowGmg:
841
    """MODFLOW geometric multigrid solver"""
842
    def __init__(
843
        self,
844
        model: Modflow,
845
        mxiter: int = 50,
846
        iiter: int = 20,
847
        iadamp: int = 3,
848
        hclose: float = 1e-5,
849
        rclose: float = 1e-5,
850
        relax: float = 0.8,
851
        ioutgmg: int = 0,
852
        iunitmhc: int = 0,
853
        ism: int = 0,
854
        isc: int = 0,
855
        damp: float = 1.0,
856
        dup: float = 0.75,
857
        dlow: float = 0.01,
858
        chglimit: float = 0.5,
859
        extension: str = 'gmg',
860
        unitnumber: int = None,
861
        filenames: str = None,
862
        **kwargs
863
    ): ...
864
```
865

866
## Observation Packages
867

868
### ModflowHob
869

870
Head observation package.
871

872
```python { .api }
873
class ModflowHob:
874
    """MODFLOW head observation package"""
875
    def __init__(
876
        self,
877
        model: Modflow = None,
878
        iuhobsv: int = 1051,
879
        hobdry: float = 0,
880
        tomulth: float = 1.0,
881
        obs_data: list = None,
882
        hobname: list = None,
883
        extension: str = 'hob',
884
        no_print: bool = False,
885
        options: list = None,
886
        unitnumber: int = None,
887
        filenames: str = None,
888
        **kwargs
889
    ): ...
890
```
891

892
### ModflowFlwob
893

894
Flow observation package.
895

896
```python { .api }
897
class ModflowFlwob:
898
    """MODFLOW flow observation package"""
899
    def __init__(
900
        self,
901
        model: Modflow,
902
        nqfb: int = 0,
903
        nqcfb: int = 0,
904
        nqtfb: int = 0,
905
        iufbobsv: int = 1052,
906
        tomultfb: float = 1.0,
907
        nqobfb: list = None,
908
        nqclfb: list = None,
909
        obsnam: list = None,
910
        irefsp: list = None,
911
        toffset: list = None,
912
        flwsim: list = None,
913
        flwobs: list = None,
914
        extension: str = 'flwob',
915
        unitnumber: int = None,
916
        filenames: str = None,
917
        **kwargs
918
    ): ...
919
```
920

921
## Usage Examples
922

923
### Basic MODFLOW 2005 Model
924

925
```python
926
import flopy
927
import numpy as np
928

929
# Create model
930
mf = flopy.modflow.Modflow(modelname='basic_model', exe_name='mf2005')
931

932
# Add discretization
933
nlay, nrow, ncol = 3, 50, 50
934
dis = flopy.modflow.ModflowDis(
935
    mf,
936
    nlay=nlay, nrow=nrow, ncol=ncol,
937
    delr=100.0, delc=100.0,
938
    top=100.0,
939
    botm=[50.0, 0.0, -50.0],
940
    nper=2,
941
    perlen=[1.0, 365.0],
942
    nstp=[1, 12],
943
    steady=[True, False]
944
)
945

946
# Add basic package
947
ibound = np.ones((nlay, nrow, ncol), dtype=int)
948
ibound[:, 0, :] = -1  # Constant head boundary
949
ibound[:, -1, :] = -1
950
bas = flopy.modflow.ModflowBas(
951
    mf,
952
    ibound=ibound,
953
    strt=75.0
954
)
955

956
# Add layer property flow
957
hk = [10.0, 5.0, 1.0]  # Different K for each layer
958
lpf = flopy.modflow.ModflowLpf(
959
    mf,
960
    hk=hk,
961
    vka=0.1,
962
    sy=0.2,
963
    ss=1e-5,
964
    laytyp=[1, 1, 0]  # Top two layers convertible
965
)
966

967
# Add recharge
968
rch = flopy.modflow.ModflowRch(mf, rech=0.001)
969

970
# Add wells
971
wel_sp_data = {
972
    0: [[0, 25, 25, -1000.0]],  # Steady state pumping well
973
    1: [[0, 25, 25, -2000.0]]   # Increased pumping in transient
974
}
975
wel = flopy.modflow.ModflowWel(mf, stress_period_data=wel_sp_data)
976

977
# Add output control
978
oc = flopy.modflow.ModflowOc(mf)
979

980
# Add solver
981
pcg = flopy.modflow.ModflowPcg(mf)
982

983
# Write input files
984
mf.write_input()
985

986
# Run model
987
success, buff = mf.run_model()
988
```
989

990
### Advanced Regional Model with Multiple Boundaries
991

992
```python
993
import flopy
994
import numpy as np
995

996
# Create regional model
997
mf = flopy.modflow.Modflow(
998
    modelname='regional_model',
999
    exe_name='mf2005',
1000
    version='mf2005'
1001
)
1002

1003
# Large grid for regional analysis
1004
nlay, nrow, ncol = 5, 200, 300
1005
dis = flopy.modflow.ModflowDis(
1006
    mf,
1007
    nlay=nlay, nrow=nrow, ncol=ncol,
1008
    delr=500.0, delc=500.0,
1009
    top=200.0,
1010
    botm=[150.0, 100.0, 50.0, 0.0, -100.0],
1011
    nper=12,  # Monthly stress periods
1012
    perlen=30.25,  # Average month length
1013
    nstp=5,
1014
    tsmult=1.2,
1015
    steady=False
1016
)
1017

1018
# Basic package with complex boundary conditions
1019
ibound = np.ones((nlay, nrow, ncol), dtype=int)
1020
# Set no-flow boundaries
1021
ibound[:, 0, :] = 0
1022
ibound[:, -1, :] = 0
1023
ibound[:, :, 0] = 0
1024
# Set constant head boundaries along one edge
1025
ibound[:, :, -1] = -1
1026

1027
bas = flopy.modflow.ModflowBas(
1028
    mf,
1029
    ibound=ibound,
1030
    strt=150.0
1031
)
1032

1033
# Layer property flow with heterogeneous properties
1034
hk_layers = [50.0, 20.0, 10.0, 5.0, 1.0]
1035
lpf = flopy.modflow.ModflowLpf(
1036
    mf,
1037
    hk=hk_layers,
1038
    vka=[5.0, 2.0, 1.0, 0.5, 0.1],
1039
    sy=0.25,
1040
    ss=1e-5,
1041
    laytyp=1,
1042
    hdry=-999.0
1043
)
1044

1045
# Seasonal recharge pattern
1046
rech_data = {}
1047
for kper in range(12):
1048
    # Higher recharge in winter months (Nov-Mar)
1049
    if kper in [10, 11, 0, 1, 2]:
1050
        rech_rate = 0.005
1051
    else:
1052
        rech_rate = 0.001
1053
    rech_data[kper] = rech_rate
1054

1055
rch = flopy.modflow.ModflowRch(mf, rech=rech_data)
1056

1057
# Multiple rivers
1058
riv_data = {}
1059
for kper in range(12):
1060
    # River stages vary seasonally
1061
    stage_mult = 1.0 + 0.2 * np.sin(2 * np.pi * kper / 12)
1062
    rivers = []
1063
    # Main river along row 50
1064
    for col in range(50, 250):
1065
        rivers.append([0, 50, col, 145.0 * stage_mult, 1000.0, 140.0])
1066
    # Tributary along column 100
1067
    for row in range(60, 120):
1068
        rivers.append([0, row, 100, 140.0 * stage_mult, 500.0, 135.0])
1069
    riv_data[kper] = rivers
1070

1071
riv = flopy.modflow.ModflowRiv(mf, stress_period_data=riv_data)
1072

1073
# General head boundaries for regional flow
1074
ghb_data = {}
1075
for kper in range(12):
1076
    ghbs = []
1077
    # Eastern boundary with regional gradient
1078
    for row in range(nrow):
1079
        head = 120.0 + (row / nrow) * 30.0  # North-south gradient
1080
        ghbs.append([0, row, ncol-1, head, 100.0])
1081
    ghb_data[kper] = ghbs
1082

1083
ghb = flopy.modflow.ModflowGhb(mf, stress_period_data=ghb_data)
1084

1085
# Municipal wells with seasonal pumping
1086
wel_data = {}
1087
well_locations = [(0, 75, 150), (1, 125, 200), (0, 160, 100)]
1088
for kper in range(12):
1089
    wells = []
1090
    # Higher pumping in summer months
1091
    if kper in [5, 6, 7, 8]:
1092
        pump_mult = 1.5
1093
    else:
1094
        pump_mult = 1.0
1095
    
1096
    base_rates = [-5000.0, -3000.0, -2000.0]
1097
    for i, (lay, row, col) in enumerate(well_locations):
1098
        rate = base_rates[i] * pump_mult
1099
        wells.append([lay, row, col, rate])
1100
    wel_data[kper] = wells
1101

1102
wel = flopy.modflow.ModflowWel(mf, stress_period_data=wel_data)
1103

1104
# Output control for detailed output
1105
stress_period_data = {}
1106
for kper in range(12):
1107
    stress_period_data[kper] = ['save head', 'save budget']
1108

1109
oc = flopy.modflow.ModflowOc(
1110
    mf,
1111
    stress_period_data=stress_period_data,
1112
    compact=True
1113
)
1114

1115
# Newton solver for better convergence
1116
nwt = flopy.modflow.ModflowNwt(
1117
    mf,
1118
    headtol=0.01,
1119
    fluxtol=500.0,
1120
    maxiterout=100,
1121
    linmeth=2  # GMRES
1122
)
1123

1124
# Write and run
1125
mf.write_input()
1126
success, buff = mf.run_model()
1127
```
1128

1129
## Common Types
1130

1131
```python { .api }
1132
# MODFLOW 2005 specific types
1133
ArrayData = Union[int, float, np.ndarray, list, str]
1134
StressPeriodData = dict[int, list[list]]
1135

1136
# Boundary condition data formats
1137
WelData = list[list[int, int, int, float]]  # [layer, row, col, flux]
1138
RivData = list[list[int, int, int, float, float, float]]  # [layer, row, col, stage, cond, rbot]
1139
GhbData = list[list[int, int, int, float, float]]  # [layer, row, col, head, cond]
1140
DrnData = list[list[int, int, int, float, float]]  # [layer, row, col, elev, cond]
1141
ChdData = list[list[int, int, int, float, float]]  # [layer, row, col, shead, ehead]
1142

1143
# Discretization arrays
1144
DelrDelc = Union[float, list[float], np.ndarray]
1145
Botm = Union[float, list[float], np.ndarray]
1146
Perlen = Union[float, list[float], np.ndarray]
1147

1148
# Package unit numbers
1149
UnitNumber = Union[int, None]
1150
```
1151

1152
This comprehensive documentation covers the complete MODFLOW 2005 API including all major packages, their parameters, and usage patterns. The examples demonstrate both basic model construction and advanced regional modeling scenarios with complex boundary conditions and temporal variations.