Is the armi reactor loaded already when sweeping with an input modifier?

[azshe]

Hi ARMI devs. I'm a nuclear engineer at Antares. We're working on some modeling tools built on the ARMI framework for a couple months now and finally came crawling out of the woodwork. I have a question on the order of operations in a parameter sweep.

Suppose I have a block in the blueprint with a few linked components, something like this:

blocks:
  block_1:
    shape: Circle
    id: 0
    od: 1
  block_2:
    shape: Circle
    id: block_1.od
    od: 2.5
  block_3: 
    shape: Circle
    id: block_2.od
    od: 3

I want to create a modifier that would preserve the thicknesses or dimensions of the other components. So I could create a modifier like this:

class thicknessOfBlockTwoModifier(inputModifiers.InputModifier):
    """Modifier that adjusts the thickness of block 2 diameter."""

    def __call__(self, cs, bp):
        for blockDesign in bp.blockDesigns:
            for componentDesign in blockDesign:
                if componentDesign.name == "block_1":
                    thickness_block_1 = componentDesign.od - componentDesign.id
                if componentDesign.name == "block_2":
                    componentDesign.od = componentDesign.id + self.independentVariable["cladThickness"]
                if componentDesign.name == "block_3":
                    thickness_block_3 = componentDesign.od - componentDesign.id
             blockDesign["block_1"].od = blockDesign["block_1"].id + thickness_block_1
             blockDesign["block_3"].id = blockDesign["block_2"].od
             blockDesign["block_3"].od = blockDesign["block_3"].id + thickness_block_3
        return cs, bp

basically manually march down the components in the block and mimic the linked components to preserve their original dimension. As far as I can tell, the inputModifiers class only reads in the blueprint as a bunch of dict entries for assembly/block/component designs. If I needed to add a new component between blocks 2 and 3, this modifier would break and needs updating to also preserve the new component(s). I'm wondering if the ARMI reactor itself is loaded when the sweep is kicked off? The motivation is to be able to use the various utility functions in the ARMI framework. Something like this:

class thicknessOfBlockTwoModifier(inputModifiers.InputModifier):
    """Modifier that adjusts the thickness of block 2 diameter."""

    def __call__(self, cs, bp):
        for block in core.getBlocks():
            for component in block.getComponents():
                <Update the dimensions of the target component and linked components programmatically> 
        return cs, bp

and not need to update the modifiers themselves if something minor in the blueprints changed, like adding or removing a component.

Alternatively if there's a different way I should be thinking about input modifiers and parameter sweeps, please let me know! Happy to solicit advice or recommendations if you guys have some lessons learned or best practices on input modifiers and parameter sweeping.

[keckler]

I do not believe that any reactor objects are created during the course of using input modifiers by default. That being said, you can really do whatever you want to within the __call__ method. So if you want to instantiate a reactor object from the bp that is passed in, then you can do that with the reactor factory.

The input modifiers are a bit of create-your-own-adventure situation. Typically they are used to create a case suite, though there isn't much magic to them until you implement whatever you want in the __call__. IMO the input modifiers are more of a concept than something you'd use right out of the box. I can elaborate on that more, if you're interested.

[azshe]

That's an interesting idea, I'll tinker around. So essentially, I could call the reactor factory and make the reactor object, do whatever I need to do utilizing the full suite of utility functions in armi. I think I need to pass back to the component/block/assembly blueprint objects anything I wanted to update from using the reactor class and return the bp, correct?

For what it's worth, I was playing around with it last week trying to do something similar to retrieving blocks or components by typeSpec flags. It's kind of fugly but it seems to work 🤷

def __call__(self, cs, bp):
        blocks = list(bp.blockDesigns)
        for block in blocks:
            for comp in block:
                # Components need not have flags assigned
                if 'COOLANT' in comp.flags and comp.shape is basicShapes.Circle and comp.flags is not None:
                    comp.od = comp.id + self.independentVariable[self.independentVarName]
                return bp

Really, the near term goal is just to have input modifiers that flexibly modify the dimensions of components in a block that has an arbitrary number of components with linked dimensions. Long term, I think we could use case suites that stacks a bunch of input modifiers to perform a parameter sweep or an analysis suite of reactor sims.

[john-science]

Sorry for being so late to the part @azshe . I've been busy and such. Sorry about that.

Is the armi reactor loaded already when sweeping with an input modifier?

Nope. This is just before the Reactor gets created.

I'm wondering if the ARMI reactor itself is loaded when the sweep is kicked off?

Chris is correct. No Reactor objects are created during input modifier execution. But, of course, the __call__ method is a blank slate where you can inject any code you want.

[john-science]

Show us what you have though! It would be fun to see.

And maybe we can help pound out some detailss!

[azshe]

Hey John, getting back into this now. I poked through more of the ARMI source code; I think the armi.cases.inputModifiers.pinTypeInputModifiers:_PinTypeAssemblyModifier class covers what I was trying to do? The first line in its __init__ method confuses me though. In practice, how could I use this method? Should I subclass it out for every type of component in a block I want to modify?

[john-science]

Do you mean this line?

armi/armi/cases/inputModifiers/pinTypeInputModifiers.py

Line 32 in 5d7d1b8

inputModifiers.InputModifier.__init__(self, {self.__class__.__name__: value})

Notice, that is basically and abstract class, but we have examples of it being used:

armi/armi/cases/inputModifiers/pinTypeInputModifiers.py

Line 90 in 5d7d1b8

class SmearDensityModifier(_PinTypeAssemblyModifier):

But, I think, more useful for you is our unit tests show examples of how to use those subclass modifiers:

armi/armi/cases/inputModifiers/tests/test_pinTypeInputModifiers.py

Line 52 in 5d7d1b8

pinTypeInputModifiers.SmearDensityModifier(0.5)(settings.Settings(), bp)