Hi,

It would be quite handy if I could use Queue.length in a wait statement, without wrapping it in a State object. E.g. something like

class Item(sim.component):
    pass


class A(sim.component):
    def __init__(self):
        self.q = sim.Queue()
    
    def process(self):
        Item().enter(self.q)
        yield self.hold(10.)

class C(sim.component):
    def __init__(self):
        self.a = A()

    def process(self):
        yield self.wait(self.a.q.length == 20)
        print("waited for 20 items in queue")

Consider the following example

import salabim as sim


class Customer(sim.Component):
    def process(self):
        # yield self.hold(0.1) # not needed to reproduce the problem, but can be reproduced if there is a yield in the process
        print("huhu")


env = sim.Environment(trace=True)

c = Customer()

c.hold(5)

env.run(1)

c.interrupt()

env.run(1)

## this does not fail, but reschedules the component despite its interrupt status without resetting the latter
c.hold(1)

env.run(1)

c.resume()

This fails at the last line when trying to resume the component with ValueError: customer.0 not interrupted.

Traceback (most recent call last):
  File "C:/brandl_data/projects/salamim_repo/mytests/hold_interrupt.py", line 27, in <module>
    c.resume()
  File "C:\brandl_data\projects\\salamim_repo\salabim.py", line 12198, in resume
    raise ValueError(self.name() + " not interrupted")
ValueError: customer.0 not interrupted

When checking the internal state of at the last statement we can see that it has preserved the interrupt status

It should handle such a situation more gracefully:

a) either it should fail already when interacting with an interrupted component (e.g. via hold as in the example) b) or an interaction with an interrupted component should clear its interrupt status.

Maybe there is an even better solution, but in any case it would be wonderful if the contract of interrupt could be detailed out better.

Could you add a git or GitHub tag for your latest release (version 2.2.23)? It can be done on this page: https://github.com/salabim/salabim/releases

The tagged release is needed for openjournals/joss-reviews#767

I observed today in the trace, that if a component triggers 2 one put-request to anonymous resources, one of them will always fail. However, analyzing the code I could identify a check which prevents the successful behavior.

`

 def honor_all(self):
     for r in self._requests:
        if r._honor_only_first and r._requesters[0] != self:
            return []
        self_prio = self.priority(r._requesters)
        if r._honor_only_highest_priority and self_prio != r._requesters._head.successor.priority:
            return []
        if self._requests[r] > 0:
            if self._requests[r] > (r._capacity - r._claimed_quantity + 1e-8):
                return []
        else:
            if -self._requests[r] > r._claimed_quantity + 1e-8:
                 return []
    return list(self._requests.keys())`

Maybe it is a numerical issue, but commenting the check if -self._requests[r] > r._claimed_quantity + 1e-8 out fixes the issue.

After that the trace will contain the following lines (R31 is the component, p31 and p32 are anonymous resources).

R31 put (request) 2.0 to p31 priority=inf 276 R31 claim -2.0 from p31 276 R31 request honor p31 scheduled for 0.300 @ 276+ mode=output 279 R31 put (request) 8.0 to p32 priority=inf 279 R31 claim -8.0 from p32 279 R31 request honor p32 scheduled for 0.300 @ 279+ mode=output

Next question coming up: Multiple components may be scheduled at common point in simulation time (e.g. t=0 which would result in at=0), but due to custom business logic in the simulation, the actual schedule comes later, e.g. t=1. Currently I only see that information in the trace. This is kind of uncomfortable when creating graphics based on the actual data of simulation run, e.g. Gantt chart.

Is there any possibility to log actual start/end time (schedule - hold - release) on component level? Rebuilding it from the strings in the trace is quite an effort actually ...

@salabim, the explanation of simple bank example 1 in the documentation mentions a couple calls that do not show up in the sample code. This includes self.leave(), and clerk.reactivate(). This is in regards to https://github.com/openjournals/joss-reviews/issues/767

It would be nice for usage and/or installation instruction to be in the readme. It would also be great to have a link directly to the ReadtheDocs documentation.

These are nice-to-haves for openjournals/joss-reviews#767

Hi,

The files in this respository need to be organized. A typical repository has the following directories:

• src/ directory for source code
• doc/ directory for documentation
• test/ directory for tests

You may also want to set this python project up as a module. There are many guides online (such as this one).

This organization is needed for openjournals/joss-reviews#767

For using labels in the AnimateMonitor function, I found out that the lines in the graph to be drawn according to the label are not scaled properly. This affects ll. 3171 - 3182 in the salabim.py.

                    self.aos.append(
                        AnimateLine(
                            spec=(0, 0, width, 0),
                            x=x,
                            y=y,
                            offsetx=offsetx,
                            offsety=label_y,
                            angle=angle,
                            linewidth=label_linewidth,
                            linecolor=label_linecolor,
                            over3d=over3d,
                        )

Comparing it to the code for drawing the text label, I see that screen_coordinates is not explicitly set to True here. Could it be related to that?

When I use AnimateText like this in a loop to show each item in a list, the animation shows the same values for all of them despite being in different locations:

a = [1,2,3,4]
for i in range(len(a)):
    sim.AnimateText(text=lambda:str(a[i]),x=0, y=100+20*i)

The screen only shows 4 "4"s as opposed to 1,2,3,4

However it works fine when I call them individually:

    sim.AnimateText(text=lambda:str(a[0]),x=0, y=100+20*0)
    sim.AnimateText(text=lambda:str(a[1]),x=0, y=100+20*1)
    sim.AnimateText(text=lambda:str(a[2]),x=0, y=100+20*2)
    sim.AnimateText(text=lambda:str(a[3]),x=0, y=100+20*3)

which could get quite cumbersome and ugly if the list is large.

Can anyone help with this? Thanks!

Hello - I love the project!

I'm playing around with it and slowly building up a simulation, trying to add features as I go. I'm stuck on trying to add behavior and I haven't been able to find the answer in the docs - I'm wondering whether what I'm trying to do is possible?

I want to add in a delay when issuing a resource to my customers. This delay will be an attribute I can parameterize. My desired behavior is:

• [X] Customers request the resource and enter the resource's queue
• [X] If the resource's available quantity < amount customer at the head of the line requests, customers wait until sufficient resources arrive
• [ ] If/when sufficient resources are available, I still want to delay the issuance, representing a lengthy issuance process (example: if waiting for a heart transplant, the heart doesn't instantly appear in your chest as soon as it arrives, the surgery takes time)

Right now, I'm accomplishing the delay as follow:

class Customer(sim.Component):
    def __init__(self, config={}):
        sim.Component.__init__(self)
        self.config = config
       
    def process(self):
        # Destructure the config dict
        _, store, n_consumed = itemgetter(
            'gen_dist', 'store', 'n_consumed')(self.config)

        # Enter the queue for resources at the store
        yield self.hold(store.config.get('clerk').issue_time)
        yield self.request((store.config.get('resource'), n_consumed))
        yield self.passivate()

Generated customers hold for the clerk's issue_time, then request the resource. This partially works, however, my "length of stay in requesters" statistics are invalid, since the issuance delay doesn't count against the time they are waiting for the resource.

Can someone point me to what I'm missing in the docs or otherwise propose a solution?

Thank you!

In some of my models I rely on the number of free spaces in a queue. Having this number available directly saves time and makes models more readable. It's also generic enough that I expect it to be useful for other Salabim simmers.

sim.Animate3dObj("12281_Container_v2_L2", x=lambda t: t, y=-40, y_translate=90, x_scale=0.1, y_scale=0.1, z_scale=0.1) produces the following error: warnings.warn("Could not set COM MTA mode. Unexpected behavior may occur.")

File E:\Anaconda3\lib\site-packages\pywavefront\visualization.py:48, in 43 return v 45 pyglet.image._nearest_pow2 = same 47 VERTEX_FORMATS = { ---> 48 'V3F': GL_V3F, 49 'C3F_V3F': GL_C3F_V3F, 50 'N3F_V3F': GL_N3F_V3F, 51 'T2F_V3F': GL_T2F_V3F, 52 # 'C3F_N3F_V3F': GL_C3F_N3F_V3F, # Unsupported 53 'T2F_C3F_V3F': GL_T2F_C3F_V3F, 54 'T2F_N3F_V3F': GL_T2F_N3F_V3F, 55 # 'T2F_C3F_N3F_V3F': GL_T2F_C3F_N3F_V3F, # Unsupported 56 } 59 def draw(instance, lighting_enabled=True, textures_enabled=True): 60 """Generic draw function"""

NameError: name 'GL_V3F' is not defined

How do I properly add an OBJ file?

AnimatePolygon should close an unclosed polygon for drawing purposes.

sim.AnimatePolygon(
    spec=[
        *(-75.0, -75.0), #sw
        *(75.0, -75.0), #nw
        *(75.0, 75.0), #ne
        *(-75.0, 75.0) #se
    ],
    linewidth=5,
    ...
)