Who sits where?

[Blackstar]

I have the following problem.
I work for an orchestra, and per stringgroup people sit in different places
each production.
They rotate clockwise, and per individual group.
example:
The first violins are divided (besides the concertmaster, fix place
ofcourse) in three groups, 1st soloists(2 people), 2nd soloists (3 people)
and tutti(6 people).
Each group rotates seperatly.
I can give everyone a distint number, but how should I get the rotation done?

The placement is as follows, seen from behind and above the group, the
concertmaster is the first and on the right side.
Next to him is one of the 1st soloists, the second 1st soloist sits behind
the concertmaster. Same for the 2nd soloist and tutti.
Here you see a visual of that placement.

1_1 CM
2_1 1_2
2_3 2_2
T_2 T_1
T_4 T_3
T_6 T_5

So the next rotation (if everyone plays) would be like this. rotation
clockwise.
desk 1 : 1_2 CM
desk 2 : 2_3 1_1
desk 3 : 2_2 2_1
desk 4 : T_4 T_2
desk 5 : T_6 T_1
desk 6 : T_5 T_3

On paper, the last rotation would look like this:

1. Concertmaster
1ste Soloist 2
2. 1ste Soloist 1
2nd soloist 3
3. 2nd soloist 1
2nd soloist 2
4. Tutti 2
Tutti 4
5. Tutti 1
Tutti 6
6. Tutti 3
Tutti 5

Is there anyone who understands my jiberisch and sees a way to get this
rotation automated? I seem to be unable to grasp it.
Should I give each a number and use another table where their numbers are
rotated? It seems logical, but I donno how to start.
A push in the right direction would be most appreciated.

regards,
Didier

 

[Jack Leach]

I've taken on a few similarly structured tasks before (that is, excuse the
oxymoron, unpredicatable patterns within a set of predictable parameters).
FWIW I'll elaborate on my experiences with it...

It makes sense that the seating pattern is going to need a complete
rebuilding every time you do this. My first attempt in this was to read what
I already had in place, and adjust it from there. This was shot down in a
hurry. Trying to programatically decipher something like this is a complete
nightmare. Far far easier, it turns out, to just rebuild it from the ground
up each time, referencing a few variables from the previous rotation to use
as offsets. Additionally, at this point both the initial seating arrangment
and any adjustments thereof can be based off the same function, making
programability a breeze after you get everything up and going.

I would think your "Stage" setup is going to be a few one-to many's. You
got the Stage, which has many SeatingRows, and the SeatingRows each have many
Groups, and each Group is going to have many Seats or Persons (you may have
a desire to include subgroups as well, as in different types of horns under
your brass section, etc).

Assuming your data is in some decent structure and you can query an entire
instance of the arrangement, your next major concern is confirming that you
have key values that will pertain to the positioning of each seat.

To do this, you will need some sort of datum identifier for each row. It
would make sense to call the center seat of each row 0 if possible, so then
we can reference individual groups and seats as 0 or positive/negetive
integers for right/left seating as the distance from the datum seat 0.

In order to establish a rotation (an arrangment based on the previous
instance of an arrangement), you will need to have a table to store each past
arrangement and a sorted identifier to facilitate choosing the correct one
when needed.

Thats should be everything we need. Now lets actually try and do something
with it.

Initial Setup - Run the function that pulls the requred groups and seating
etc, and place them as required. Ex: Row1 Group1 Spans -2to3, Row1 Group2
Spans -8to-3, Row1 Group3 Spans 4to6, Row2 Group1 etc. Save all this data
into a table of instances that you can call back on.

Rotation - Pull the info for the last instance from your table per above,
and start running some addition/subtract functions to offset whatever values
were in place, based on what you want to do with them. This is entirely
dependant upon how you want to adjust your arrangement, but there has to be a
system to it, otherwise you can't program a rotation. Calculate what offsets
to use, and then apply the those offsets to the previous data, which gives
you the next instance. Save this to your instance table and repeat.


In case you haven't noticed, this is a severe b*tch to do, but it is
possible. The keys are to have a datum reference to base everything off, and
have a programmable system for the rotation.

At least, this has been the only way I could manage it. Not a ton of fun
really, even for someone that likes a challenge.

Hopefully this spreads some sort of light on the subject for you! And also
hopefully, someone will have a much much easier way to handle it that I
haven't thought of.

good luck!
--
Jack Leach
www.tristatemachine.com

"I haven't failed, I've found ten thousand ways that don't work."
-Thomas Edison (1847-1931)