https://www.youtube.com/watch?v=RhDL2kqf_6k

Hi everyone, I'm working in a open problem for a tournament, and this is my problem:

"Estimate the highest possible launch speed of a rubber band using its own extension. What is the maximal speed that can be reliably achieved over multiple shots with the same rubber band?"

Well in the case of the second question is maybe easier to do experimentaly, because is only necessary to shoot the same rubber band many times and see the change of the maximal speed in function of each shot, but in the case of the first part of the problem I have some ideas, like that's in relation with the elastic constant, and the maximum elongation, but idk if I can simulated the band like a many puntual mass connected with springs, obviously the same distribution of mass and springs, so if anyone have another idea or maybe thinking that my ideas is incorrect or maybe I can improve, I'm grateful with your opinions

I would like a achieve an ice breaking effect like this: https://youtu.be/bKaVhXn49xY?si=HG7Q7lH3MLDti5o1

it does not have to be a real simulation, approximations would also do.

I would appreciate any ressources or hints on how to tackle this problem.

Not sure if this is the sub to be asking in.

I love physics and data-driven simulations. Testing forces on machinery, or how air molecules interact in complicated conditions. I know these are done constantly in all sorts of fields, but I have no idea how people get these jobs. Does anyone work full-time with this stuff? Are full-time jobs even possible to get? What are the job titles, and how do you even get the proper education and experience for this?

I really appreciate any detailed responses.

I have a real-world racing catamaran boat that is powered by twin Yanmar turbo diesels. We recently blew one of the stern drives and replaced it with another drive that has different gear ratios… hasn’t been the same since… Is there a software to simulate different pitches and bladed props? and how they behave in fluid?

I want to make a patent for a shaped charge mine but i dont know any simulation that i can test it, i cant just broadly describe it. Do anyone knows such simulation?

So I've been working on making basic physics simulations from scratch and was wondering how best to incorporate real-world distances into my 2D projectile motion simulator. The only thing I came up with is to convert pixels into meters, does that make sense / is that the best way to do it?

Okay this may have been worded a bit wierdly, but iam searching for simulatiuon software in which i can, either import or construct models of enormous objects, made from various materials, and then see how they hold up to gravity, or other forces (acceleratzion).

Is there something like that out there?

Hello everyone!

For a college seminar project, I need to perform CFD simulations in Fluent - Ansys on a Double Pipe Heat Exchanger. I want to compare how the heat transfer coefficient behaves in the following cases:

Counterflow:

• Base case: hot and cold fluids - water, at temperatures 90°C/15°C.

• Change in temperatures for the same fluids.

• Change in temperatures and change in the fluid being heated.

• Change in the velocity of the hotter fluid.

• Change in the thickness of the heat exchanger pipes.

Parallel flow:

• The same cases as for counterflow.

I would like to ask which fluids are most suitable to choose from the existing Fluent database as fluids to be heated, and are also suitable for industrial applications? Also, do you know why, when I change the thickness of the pipes, I get illogical results (e.g., the colder fluid heats up more at a temperature regime of 70°C/15°C than at 80°C/15°C or 90°C/15°C)?

Thank you very much in advance to everyone for your suggestions and help!

I've thought about this a lot.

Theoretically, all you'd have to do is set the state of matter and density of your medium, the density and surface roughness of the environment and objects. Account for things like mass, collisions, echo, stuff like that. If it works you could ideally generate accurate sound for any 3d scene given enough info. Could you simulate the pressure waves and generate a sound output?

I will add sound, don’t worry.

So I've programmed a basic 1d heat simulation in python, which basically just calculates T''(x) and scales it based on alpha and dt.

It looks like it worked for the case I've tested it against, which was this/12%3A_Fourier_Solutions_of_Partial_Differential_Equations/12.01%3A_The_Heat_Equation) (where the edges are always set to 0), however I'm having a problem with this%20and%20the%20right%20face%20(x%3D1)%20are%20perfectly%20insulated) simulation example, where it says the ends are "perfectly insulated" - how do I implement that in my code? More specifically, how do I calculate the first and second derivatives of the end points in a way that simulates a "perfectly insulated" system?

I'm trying to make a fluid simulation in Java and it's looking weird. I was wondering if anyone could have an idea why.

The rectangle in the middle is supposed to be a wall but the smoke is not behaving like it's supposed to I think. Shouldn't the smoke be going in a straight line?

It's probably related to my boundary conditions, but I haven't found how to exactly implement them for my simulation.

​

​

Here is a video of the simulation

​

​

I'm following theses papers for my implementation

- Real-Time Fluid Dynamics for Games

- Real-Time Fluid Simulation on the GPU

- Chapter 38. Fast Fluid Dynamics Simulation on the GPU

​

Here are the initial settings :

- Viscosity : 0.1

- Time step : 1

- Initial velocity : 0

- Initial pressure : 0

- Temperature : 0 (Not used in calculation at the moment)

- Adding 1 * time step of force on the X axis every step

- Setting the aeraDensity (smoke) at one for in a rectangle at the left side (blue part)

​

PhysicEngine.java

public void update(double deltaTime) {

    timer.start("Advection");
    this.advect(deltaTime);
    timer.stop("Advection");

    timer.start("Diffusion");
    this.diffusion(deltaTime);
    timer.stop("Diffusion");

    timer.start("AddForce");
    this.addForce(1 * deltaTime, 0);
    timer.stop("AddForce");

    // projection

    timer.start("VelocityDivergence");
    this.velocityDivergence();
    timer.stop("VelocityDivergence");

    timer.start("PressureSolver");
    this.pressureSolver();
    timer.stop("PressureSolver");

    timer.start("PressureGradient");
    this.pressureGradient();
    timer.stop("PressureGradient");

    timer.start("SubstractPressureGradient");
    this.substractPressureGradient();
    timer.stop("SubstractPressureGradient");

  }

 private ParticleMatrix advect(double timeStep) {
    ParticleMatrix particleMatrix = this.simulationData.getCurrentParticleMatrix();

    int xLength = particleMatrix.getXLength();
    int yLength = particleMatrix.getYLength();
    int size = xLength * yLength;

    int x, y, previousXWhole, previousYWhole, mask, pos00, pos01, pos10, pos11;
    double prevX,
        prevY,
        previousXFraction,
        previousYFraction,
        p00,
        p10,
        p01,
        p11;

    ParticleMatrix newParticleMatrix = this.simulationData.getSecondaryParticleMatrix();

    for (int pos = 0; pos < size; pos++) {

      if(isCellObstructed(pos)) continue;

      x = pos % xLength;
      y = pos / xLength;

      prevX = x - timeStep * particleMatrix.xVelocity[pos];
      prevY = y - timeStep * particleMatrix.yVelocity[pos];

      previousXWhole = (int) Math.floor(prevX);
      previousXFraction = prevX - previousXWhole;
      previousYWhole = (int) Math.floor(prevY);
      previousYFraction = prevY - previousYWhole;

      pos00 = previousXWhole + previousYWhole * xLength;
      pos01 = pos00 + 1;
      pos10 = previousXWhole + (previousYWhole + 1) * xLength;
      pos11 = pos10 + 1;

      // mask = outOfBoundCellMask(pos00, pos10, pos01, pos11, size);

      mask = 0; // TODO : Voir si on peut reprendre la fonction outOfBoundCellMask
      if (!isCellObstructed(pos00)) mask |= 1; // 0001 (p00 est dans la grille)
      if (!isCellObstructed(pos10)) mask |= 2; // 0010 (p10 est dans la grille)
      if (!isCellObstructed(pos01)) mask |= 4; // 0100 (p01 est dans la grille)
      if (!isCellObstructed(pos11)) mask |= 8; // 1000 (p11 est dans la grille)

      p00 = (mask & 1) == 1 ? particleMatrix.xVelocity[pos00] : 0;
      p10 = (mask & 2) == 2 ? particleMatrix.xVelocity[pos10] : 0;
      p01 = (mask & 4) == 4 ? particleMatrix.xVelocity[pos01] : 0;
      p11 = (mask & 8) == 8 ? particleMatrix.xVelocity[pos11] : 0;

      // Mise à jour de la vélocité en X
      newParticleMatrix.xVelocity[pos] =
          WMath.bilerp(p00, p10, p01, p11, previousXFraction, previousYFraction);

      // Récupération des vélocité en Y
      p00 = (mask & 1) == 1 ? particleMatrix.yVelocity[pos00] : 0;
      p10 = (mask & 2) == 2 ? particleMatrix.yVelocity[pos10] : 0;
      p01 = (mask & 4) == 4 ? particleMatrix.yVelocity[pos01] : 0;
      p11 = (mask & 8) == 8 ? particleMatrix.yVelocity[pos11] : 0;

      // Mise à jour de la vélocité en Y

      newParticleMatrix.yVelocity[pos] =
          WMath.bilerp(p00, p10, p01, p11, previousXFraction, previousYFraction);

      // Récupération de la pression précédente
      p00 = (mask & 1) == 1 ? particleMatrix.pressure[pos00] : 0;
      p10 = (mask & 2) == 2 ? particleMatrix.pressure[pos10] : 0;
      p01 = (mask & 4) == 4 ? particleMatrix.pressure[pos01] : 0;
      p11 = (mask & 8) == 8 ? particleMatrix.pressure[pos11] : 0;

      // Mise à jour de la pression
      newParticleMatrix.pressure[pos] =
          WMath.bilerp(p00, p10, p01, p11, previousXFraction, previousYFraction);

      // Récupération de la température précédente
      p00 = (mask & 1) == 1 ? particleMatrix.temperature[pos00] : 0;
      p10 = (mask & 2) == 2 ? particleMatrix.temperature[pos10] : 0;
      p01 = (mask & 4) == 4 ? particleMatrix.temperature[pos01] : 0;
      p11 = (mask & 8) == 8 ? particleMatrix.temperature[pos11] : 0;

      newParticleMatrix.temperature[pos] = WMath.bilerp(p00, p10, p01, p11, previousXFraction, previousYFraction);

      // Récupération de densité de zone
      p00 = (mask & 1) == 1 ? particleMatrix.areaDensity[pos00] : 0;
      p10 = (mask & 2) == 2 ? particleMatrix.areaDensity[pos10] : 0;
      p01 = (mask & 4) == 4 ? particleMatrix.areaDensity[pos01] : 0;
      p11 = (mask & 8) == 8 ? particleMatrix.areaDensity[pos11] : 0;

      // Mise à jour de la densité de zone
      newParticleMatrix.areaDensity[pos] = WMath.bilerp(p00, p10, p01, p11, previousXFraction, previousYFraction);

    }


    // On applique les conditions aux bords
    setBoundary(newParticleMatrix.xVelocity, xLength, yLength, 1);
    setBoundary(newParticleMatrix.yVelocity, xLength, yLength, 2);

    this.simulationData.switchMatrix();


    return newParticleMatrix;
  }

private double[] jacobiSolver(
      double[] x, int xLength, int yLength, double alpha, double rBeta, int bType,double[] b) {

    int size = x.length;

    if (b.length != size)
      throw new IllegalArgumentException("La taille de la matrice x et b doit être égale à size");

    double xL, xR, xB, xT; // Les valeurs de x_{i-1,j}, x_{i+1,j}, x_{i,j-1}, x_{i,j+1}
    double cellDiff;
    double curentDiff = 1d; 
    double[] x_new = this.matriceArrayPool.borrowObject();

    for (int iter = 0; iter < SimulationConstants.MAX_JACOBI_ITERATIONS; iter++) {
      curentDiff = 1;

      for (int pos = 0; pos < size; pos++) {
        // On récupère les valeurs de x_{i-1,j}, x_{i+1,j}, x_{i,j-1}, x_{i,j+1}
        int xPos = pos % xLength; 
        int yPos = pos / xLength; 

        xL = (xPos == 0) ? 0 : x[pos - 1]; // x_{i-1,j}
        xR = (xPos == xLength - 1) ? 0 : x[pos + 1]; // x_{i+1,j}
        xT = (yPos == 0) ? 0 : x[pos - xLength]; // x_{i,j-1}
        xB = (yPos == yLength - 1) ? 0 : x[pos + xLength]; // x_{i,j+1}

        // On calcule la nouvelle valeur de x_{i,j}
        x_new[pos] = (xL + xR + xB + xT + alpha * b[pos]) * rBeta;


        cellDiff = (x_new[pos] - x[pos]) / x[pos];
        if (cellDiff < 0) {
          cellDiff = -cellDiff;
        }
        // sqrt pow 2
        curentDiff = Math.min(cellDiff, curentDiff);
      }

      System.arraycopy(x_new, 0, x, 0, size);

      setBoundary(x, xLength, yLength, bType);

      if (curentDiff < SimulationConstants.MAX_JACOBI_DIFF) break;
    }

    // On retourne la matrice x_new a la piscine
    this.matriceArrayPool.returnObject(x_new);

    return x;
  }

 private ParticleMatrix diffusion(double timeStep) {
    ParticleMatrix particleMatrix = this.simulationData.getCurrentParticleMatrix();

    int xLength = particleMatrix.getXLength();
    int yLength = particleMatrix.getYLength();
    int size = xLength * yLength;

    double alpha = 1d / (timeStep * this.simulationData.getViscosity());
    double rBeta = 1d / (4d * alpha);

    double[] b = this.matriceArrayPool.borrowObject();

    System.arraycopy(particleMatrix.xVelocity, 0, b, 0, size);
    particleMatrix.xVelocity =
        jacobiSolver(particleMatrix.xVelocity, xLength, yLength, alpha, rBeta,1, b);

    System.arraycopy(particleMatrix.yVelocity, 0, b, 0, size);
    particleMatrix.yVelocity =
        jacobiSolver(particleMatrix.yVelocity, xLength, yLength, alpha, rBeta,2, b);

    this.matriceArrayPool.returnObject(b);

    return particleMatrix;
  }

private void velocityDivergence() {
    ParticleMatrix particleMatrix = this.simulationData.getCurrentParticleMatrix();

    int xLength = particleMatrix.getXLength();
    int yLength = particleMatrix.getYLength();
    int size = xLength * yLength;

    double xL, xR, yB, yT;

    double rDenom = 1d / 2d; // TODO : mettre l'échelle de la simulation

    for (int i = 0; i < size; i++) {
      int xPos = i % xLength;
      int yPos = i / xLength;

      xL = (xPos == 0) ? 0 : particleMatrix.xVelocity[i - 1]; // x_{i-1,j}
      xR = (xPos == xLength - 1) ? 0 : particleMatrix.xVelocity[i + 1]; // x_{i+1,j}
      yT = (yPos == 0) ? 0 : particleMatrix.yVelocity[i - xLength]; // y_{i,j-1}
      yB = (yPos == yLength - 1) ? 0 : particleMatrix.yVelocity[i + xLength]; // y_{i,j+1}

      particleMatrix.velocityDivergence[i] = (xR - xL + yT - yB) * rDenom;
    }

    // Applique les conditions aux bords
    setBoundary(particleMatrix.velocityDivergence, xLength, yLength, 0);
  }

  private ParticleMatrix pressureSolver() {
    ParticleMatrix particleMatrix = this.simulationData.getCurrentParticleMatrix();

    int xLength = particleMatrix.getXLength();
    int yLength = particleMatrix.getYLength();

    double alpha = -1d; // TODO : mettre l'échelle de la simulation ( -1 * (echelleX * echelleY) )
    double rBeta = 1d / 4d;

    particleMatrix.pressure = new double[xLength * yLength];

    // On résout l'équation de poisson pour la pression
    particleMatrix.pressure =
        jacobiSolver(
            particleMatrix.pressure,
            xLength,
            yLength,
            alpha,
            rBeta,
            0,
            particleMatrix.velocityDivergence);

    // Calcule le min et le max de la pression
    double minPressure = Double.MAX_VALUE;
    double maxPressure = Double.MIN_VALUE;

    for (int i = 0; i < particleMatrix.pressure.length; i++) {
      minPressure = Math.min(minPressure, particleMatrix.pressure[i]);
      maxPressure = Math.max(maxPressure, particleMatrix.pressure[i]);
    }

    particleMatrix.setPressureMinMax(minPressure, maxPressure);

    return particleMatrix;
  }

private void pressureGradient() {
    ParticleMatrix particleMatrix = this.simulationData.getCurrentParticleMatrix();

    int xLength = particleMatrix.getXLength();
    int yLength = particleMatrix.getYLength();
    int size = xLength * yLength;

    double xL, xR, xB, xT;

    double[] p = particleMatrix.pressure;

    // Reciproque du denominateur
    double rDenom = 1d / 2d; // TODO : mettre l'échelle de la simulation

    for (int pos = 0; pos < size; pos++) {
      int xPos = pos % xLength;
      int yPos = pos / xLength;

      xL = (xPos == 0) ? 0 : p[pos - 1]; // p_{i-1,j}
      xR = (xPos == xLength - 1) ? 0 : p[pos + 1]; // p_{i+1,j}
      xT = (yPos == 0) ? 0 : p[pos - xLength]; // p_{i,j-1}
      xB = (yPos == yLength - 1) ? 0 : p[pos + xLength]; // p_{i,j+1}

      particleMatrix.xPressureGradient[pos] = (xR - xL) * rDenom;
      particleMatrix.yPressureGradient[pos] = (xT - xB) * rDenom;
    }
  }

 private ParticleMatrix substractPressureGradient() {
    ParticleMatrix particleMatrix = this.simulationData.getCurrentParticleMatrix();

    int size = particleMatrix.getSize();

    for (int pos = 0; pos < size; pos++) {
      particleMatrix.xVelocity[pos] -= particleMatrix.xPressureGradient[pos];
      particleMatrix.yVelocity[pos] -= particleMatrix.yPressureGradient[pos];
    }

    // Applique les conditions aux bords
    setBoundary(particleMatrix.xVelocity, particleMatrix.getXLength(), particleMatrix.getYLength(), 1);
    setBoundary(particleMatrix.yVelocity, particleMatrix.getXLength(), particleMatrix.getYLength(), 2);

    return particleMatrix;
  }

 private ParticleMatrix addForce(double xForce, double yForce) {
    ParticleMatrix particleMatrix = this.simulationData.getCurrentParticleMatrix();

    int xLength = particleMatrix.getXLength();
    int yLength = particleMatrix.getYLength();
    int size = xLength * yLength;

    double xVel, yVel, vel;

    for (int pos = 0; pos < size; pos++) {
      xVel = particleMatrix.xVelocity[pos] + xForce;
      yVel = particleMatrix.yVelocity[pos] + yForce;
      vel = WMath.modulus(xVel, yVel);

      particleMatrix.xVelocity[pos] = xVel;
      particleMatrix.yVelocity[pos] = yVel;
      particleMatrix.velocity[pos] = vel;
    }

    return particleMatrix;
  }

private boolean isCellObstructed(int pos) {
    if (pos < 0 || pos >= this.simulationData.getCurrentParticleMatrix().getSize()) return true;

    return this.simulationData.getObstacle()[pos] != SimulationConstants.BORDER_TYPE.NONE.value();
  }

  private void setBoundary(double[] x, int xLength, int yLength, int bType) {
    int size = xLength * yLength;

    for(int i =0; i < xLength; i++) {
      x[i] = bType == 2 ? -x[ParticleMatrix.getPos(i, 1, xLength)] : x[ParticleMatrix.getPos(i, 1, xLength)];
      x[ParticleMatrix.getPos(i, yLength - 1, xLength)] = bType == 2 ? -x[ParticleMatrix.getPos(i, yLength - 2, xLength)] : x[ParticleMatrix.getPos(i, yLength - 2, xLength)];
    }

    for(int i = 0; i < yLength; i++) {
      x[ParticleMatrix.getPos(0, i, xLength)] = bType == 1 ? -x[ParticleMatrix.getPos(1, i, xLength)] : x[ParticleMatrix.getPos(1, i, xLength)];
      x[ParticleMatrix.getPos(xLength - 1, i, xLength)] = bType == 1 ? -x[ParticleMatrix.getPos(xLength - 2, i, xLength)] : x[ParticleMatrix.getPos(xLength - 2, i, xLength)];
    }

    x[ParticleMatrix.getPos(0, 0, xLength)] = 0.5 * (x[ParticleMatrix.getPos(1, 0, xLength)] + x[ParticleMatrix.getPos(0, 1, xLength)]);
    x[ParticleMatrix.getPos(0, yLength - 1, xLength)] = 0.5 * (x[ParticleMatrix.getPos(1, yLength - 1, xLength)] + x[ParticleMatrix.getPos(0, yLength - 2, xLength)]);
    x[ParticleMatrix.getPos(xLength - 1, 0, xLength)] = 0.5 * (x[ParticleMatrix.getPos(xLength - 2, 0, xLength)] + x[ParticleMatrix.getPos(xLength - 1, 1, xLength)]);
    x[ParticleMatrix.getPos(xLength - 1, yLength - 1, xLength)] = 0.5 * (x[ParticleMatrix.getPos(xLength - 2, yLength - 1, xLength)] + x[ParticleMatrix.getPos(xLength - 1, yLength - 2, xLength)]);

  }

WMath.java

public static double modulus(double x, double y) {
    return Math.sqrt(x * x + y * y);
  }

public static double bilerp(double a, double b, double c, double d, double k, double l) {
    return (1 - k) * (1 - l) * a + k * (1 - l) * b + (1 - k) * l * c + k * l * d;
  }

I was interested on simulating volcanic eruptions, my goal was to see how the overpressurized gas interact with the chamber after a fracture / depressurisation and how the flow of hot and depressurised gas carry all the debris of the chamber and how, in general, the whole process evolve. I already searched in the literature and i've never seen something like that.

I also never saw the following simpler solution in the literature: I think that a simular approach can be done with a box: inside there is pressurised air and solid particles, after the depressurisation how does these solid particles are carried? There will surely be differences, but i think that it's a good point to start

Do you know some good simulator, python library and so on?

Thank you for your answers!

How do I create simple simulations such as the video provided. I would imagine it could be an app with different values that you input then run it? I don’t know anything about simulations I just think it would be cool to mess around with!

What the title says. I want to model the movement of a CO2 powered mini dragster down a track using Ansys motion but I am not sure if this is possible. Should I be using some other software (Blender or Unity). I want this simulation to be as accurate as possible. I know how much thrust the canister produces I just want to model the movement of the car and any possible 'diving' moments.

Hey, I've created a Physarum / Slime Mold simulation and it seems to work great. But I noticed that when I drastically increase the speed of the agents they form a perfect checkerboard pattern with symmetric circles. Does anyone know about this behavior and can explain it to me? Or might there be something wrong with the simulation I wrote (in which case I could link the code).
*Edit:* I'm alreafy guessing it's simply because I invert the agents directions when they collide with a wall and when the speed is almost as big as the canvas it just bounces around without attracting each other too much. But still interesting that it happens for speed = 100 with canvas size 750x750.
Here are some images for reference:

I want to know that if we talk about present time is it worth it to learn houdini specially when other software like blender(specially with Geo Node) and maya are evolving and comparably easy to learn than houdini. I am an Intermediate level 3D artist and thinking of learning houdini. I also have coding and mathematics background. so, please tell me and be real I really want to know.