%% Code to explain the displacement of SPH particles (amorphous) along a rigid wall made with beads of the same size (organized)
% INRAE\Olivier Vitrac, Han Chen - 2023-02-23

% [ SYNOPSIS ] This code simulates the displacement of spherical particles in a rigid wall made with beads of the
% same size, by calculating the normal force and contact radius between the particles % and the wall. The contact
% depth between each pair of particles and the wall is calculated using the Hertz model.

% [ DESCRIPTION ] The code simulates the displacement of amorphous fluid particles along a
% rigid wall made of beads of the same size that are organized in a fixed pattern. The code
% defines the initial configuration of the system, with the wall and fluid beads arranged in their
% respective layers. The fluid beads are then redistributed with some randomness along the x-axis.
% The code then finds the closest wall bead to each fluid bead and calculates the contraction
% required for the fluid bead to move towards the wall bead. The final configuration of the fluid
% beads is then computed with the required contraction, and the physical interpretation of the
% contraction is calculated using Hertz contact mechanics. The dynamic configuration is then plotted,
% showing the motion of the fluid beads towards the wall beads, with arrows indicating the force
% direction and magnitude. The code also allows the user to record a video of the dynamic configuration.

%% layer definitions and initial configuration
% The code defines the properties of the wall and the fluid particles,
% including their size, number, and position. The particles are initially
% randomly distributed along the x-axis, and then redistributed to the
% nearest wall bead with some randomness.

% layer plot
layerplot = @(X) viscircles([X.x X.y],X.R*ones(X.n,1),'color',X.color);
% bead size
r = 0.5;
wall = struct( ...
    'R',r, ...
    'n',14,...
    'y',-r,...
    'dx',1e-2,...
    'dy',0,...
    'color',rgb('DarkBlue') ...
    );

fluid = struct( ...
    'R',r,...
    'n',10,...
    'y',+r,...
    'dx',1e-2,...
    'dy',1e-2,...
    'color',rgb('Gold') ...
    );
wall.x  = linspace(-(wall.dx+wall.R*2)*(wall.n-1)/2,(wall.dx+wall.R*2)*(wall.n-1)/2,wall.n)';
fluid.x = linspace(-(fluid.dx+fluid.R*2)*(fluid.n-1)/2,(fluid.dx+fluid.R*2)*(fluid.n-1)/2,fluid.n)';
wall.y = ones(wall.n,1) * (wall.y + wall.dy);
fluid.y = ones(fluid.n,1) * (fluid.y + fluid.dy);
% redistribute with some randomness fluid beads along x
x0 = fluid.x(1);
dx = diff(fluid.x);
dxrandom = abs(randn(fluid.n,1))*fluid.R*0.5;
x = x0+[cumsum([0;dx]+dxrandom)];
fluid.x = x - mean(x);

% find the closest wall bead and calculate the final configuration (used to get fmax)
distance = @(i) sqrt((wall.x-fluid.x(i)).^2 + (wall.y-fluid.y(i)).^2);
iclosest = arrayfun( @(i) find( distance(i)==min(distance(i)),1),1:fluid.n );
distance2closest = sqrt((wall.x(iclosest)-fluid.x).^2 + (wall.y(iclosest)-fluid.y).^2);
dtarget = wall.R*2*(1-abs(randn(fluid.n,1)*0.02));
contraction_required = 1-dtarget./distance2closest;
final = fluid;
final.x = final.x + (wall.x(iclosest)-final.x) .* contraction_required;
final.y = final.y + (wall.y(iclosest)-final.y) .* contraction_required;


% Physical intepretation
% The force required to maintain the contact between the particles and the wall is
% calculated based on the Hertz model, and the dynamic configuration of the particles
% is then calculated using the applied load.
distance2closest = sqrt((wall.x(iclosest)-final.x).^2 + (wall.y(iclosest)-final.y).^2);
E = 1e5;
rcut = wall.R + final.R;
direction = - [wall.x(iclosest)-final.x (wall.y(iclosest)-final.y)]./distance2closest(:,[1 1]);
f = E * sqrt((rcut-distance2closest)*wall.R*final.R/rcut);
f(distance2closest>rcut) = 0;
fmax = max(f);

% dynamic configuration
nt = 200;
t = linspace(0,1,nt);
clf, hold on, axis equal
layerplot(wall)
[hp,ha] = deal([]);
axis off
RECORD = true; % set it to true to record a video

% The code then iterates over a certain number of time steps,calculating
% the dynamic configuration of the particles in each step and plotting their
% positions and contact depths using the Hertz model.
for it = 1:nt
    layerplot(fluid)
    config = fluid;
    config.x = config.x + (wall.x(iclosest)-config.x) .* contraction_required*t(it);
    config.y = config.y + (wall.y(iclosest)-config.y) .* contraction_required*t(it);

    % Physical intepretation
    distance2closest = sqrt((wall.x(iclosest)-config.x).^2 + (wall.y(iclosest)-config.y).^2);
    min(distance2closest)
    rcut = wall.R + config.R;

    direction = - [wall.x(iclosest)-config.x (wall.y(iclosest)-config.y)]./distance2closest(:,[1 1]);
    f = E * sqrt((rcut-distance2closest)*wall.R*config.R/rcut);
    f(distance2closest>rcut) = 0;
    fmax = max(f);
    fscale = 2*r/fmax;
    start = [config.x config.y];
    stop = start + direction.*f*fscale;
    start(f==0,:)=[];
    stop(f==0,:)=[];

    % plot
    if ~isempty(hp), delete(hp); end
    if ~isempty(ha), delete(ha); end
    hp = layerplot(config);
    if any(start)
        ha = [
            arrow(start,stop,'length',8,'BaseAngle',60,'Linewidth',2,'color',rgb('ForestGreen'),'Edgecolor',rgb('ForestGreen'))
            arrow(start,[stop(:,1) start(:,2)],'length',4,'BaseAngle',60,'color',rgb('Tomato'))
            arrow(start,[start(:,1) stop(:,2)],'length',4,'BaseAngle',60,'color',rgb('Tomato'),'EdgeColor',rgb('Tomato'))
            ];
    else
        ha = [];
    end
    drawnow

   % record video
   if RECORD
       gif_add_frame(gca,'hertz.gif',15);
   end

end
    
%% Template
% A similar code template is also provided at the end, which calculates the Hertz contact depth
% between two series of parallel spheres aligned along the x-axis, with a fixed distance between
% adjacent spheres. It calculates the normal force and contact radius based on the material
% properties of the spheres, and then loops over all possible pairs of spheres to calculate
% the Hertz contact depth between them. Finally, it plots the sphere positions and contact depths.


% % This code assumes that the two series of parallel spheres are aligned 
% % along the x-axis, with a fixed distance between adjacent spheres. 
% % It calculates the normal force and contact radius based on the material 
% % properties of the spheres, and then loops over all possible pairs of spheres
% % to calculate the Hertz contact depth between them. 
% % Finally, it plots the sphere positions and contact depths. 
% % You can modify the code to suit your specific geometry and material properties.
% 
% % Define material properties
% E = 2.1e11; % Young's modulus in Pa
% v = 0.3; % Poisson's ratio
% R = 0.5e-3; % Sphere radius in m
% 
% % Define sphere geometry and spacing
% n1 = 10; % Number of spheres in the first row
% n2 = 10; % Number of spheres in the second row
% d = 1e-3; % Distance between spheres in m
% 
% % Calculate normal force and contact radius
% P = 1; % Applied load in N
% a = (3*P*(1-v^2)/(4*E))^(1/3); % Contact radius in m
% F = 4/3*E*sqrt(R)*a^(3/2); % Normal force in N
% 
% % Define sphere positions
% x1 = linspace(-d*(n1-1)/2,d*(n1-1)/2,n1);
% x2 = linspace(-d*(n2-1)/2,d*(n2-1)/2,n2)+1e-4;
% y1 = -R;
% y2 = 0.98*R;
% 
% % Initialize contact matrix
% C = zeros(n1,n2);
% 
% % Loop over all sphere pairs and calculate contact
% for i = 1:n1
%     for j = 1:n2
%         dx = x2(j) - x1(i);
%         if abs(dx) > d
%             % Spheres are too far apart to be in contact
%             continue;
%         end
%         r = sqrt( (x2(j) - x1(i))^2 + (y2 - y1)^2 );
%         if r >= 2*R
%             % Spheres are not in contact
%             continue
%         end
%         C(i,j) = a - sqrt((2*R-r)*r); % Hertz contact depth in m
%     end
% end
% 
% %% Plot sphere positions and contact depths
% figure, hold on
% for i = 1:n1
%     viscircles([x1(i) y1],R,'color','b');
%     for j = 1:n2
%         viscircles([x2(j) y2],R-C(i,j),'color','r');
%         if C(i,j) > 0
%             plot([x1(i),x2(j)],[y1+R,y1+R-C(i,j)],'k');
%         end
%     end
% end
% axis equal

%% Code to illustrate the developement Landshoff forces between two horizontal layers of layer particles
% translating respectively to each other with a velocity difference

% INRAE\Olivier Vitrac, Han Chen - 2023-02-23

% [ SYNOPSIS ] This code simulates the displacement of two layers of particles
% in a fluid using smoothed particle hydrodynamics (SPH). The two layers are
% represented by the "fixed" and "movable" structures, which contain information
% about the size, number, position, and velocity of the particles in each layer.

% [ DESCRIPTION ] The code simulates the movement of two layers of particles in a fluid
% using smoothed particle hydrodynamics (SPH). The particles in the two layers are
% represented by the "fixed" and "movable" structures, which contain information about
% the size, number, position, and velocity of the particles in each layer. The Landshoff
% forces between particles in the two layers are calculated using the kernel function and
% SPH parameters, and the positions of the particles in the "movable" layer are adjusted
% to be as close as possible to the particles in the "fixed" layer. The forces are plotted
% as arrows on the particle plot using the "arrow" function, and the plot is updated with
% each iteration. The code also includes options for recording the plot as a GIF.


%% The code begins by defining the "layerplot" function, which creates a scatter plot of the particles
% in a layer using circles with a radius equal to the particle size.
% The particle size is set to 0.5 units for both layers, and the "fixed" layer contains 14 particles,
% while the "movable" layer contains 10 particles. The particles in the "fixed" layer are arbitrarily
% fixed in place, while the particles in the "movable" layer are free to move.
% layer plot
layerplot = @(X) viscircles([X.x X.y],X.R*ones(X.n,1),'color',X.color);
% bead size
r = 0.5;
fixed = struct( ...these particles are arbitrarily fixed
    'R',r, ...
    'n',14,...
    'y',-r,...
    'dx',1e-2,...
    'dy',0,...
    'color',rgb('DodgerBlue'),...
    'id',0 ...
    );

movable = struct( ... movable particles
    'R',r,...
    'n',10,...
    'y',+r,...
    'dx',1e-2,...
    'dy',1e-2,...
    'color',rgb('DeepSkyBlue'), ...
    'id',1 ...
    );

% The positions of the particles in each layer are initiallyset up in a linear array along the x-axis,
% with some randomness added to the spacing between particles.
% The positions of the particles in the "fixed" layer are then shifted along the y-axis
% by a fixed amount, while the positions of the particles in the "movable" layer are shifted
% by a smaller amount along both the x- and y-axes.
fixed.x  = linspace(-(fixed.dx+fixed.R*2)*(fixed.n-1)/2,(fixed.dx+fixed.R*2)*(fixed.n-1)/2,fixed.n)';
movable.x = linspace(-(movable.dx+movable.R*2)*(movable.n-1)/2,(movable.dx+movable.R*2)*(movable.n-1)/2,movable.n)';
fixed.y = ones(fixed.n,1) * (fixed.y + fixed.dy);
movable.y = ones(movable.n,1) * (movable.y + movable.dy);

% redistribute with some randomness fixed beads along x
x0 = fixed.x(1);
dx = diff(fixed.x);
dxrandom = abs(randn(fixed.n,1))*fixed.R*0.25;
x = x0+[cumsum([0;dx]+dxrandom)];
fixed.x = x - mean(x);

% redistribute with some randomness top beads along x
x0 = movable.x(1);
dx = diff(movable.x);
dxrandom = abs(randn(movable.n,1))*movable.R*0.4;
x = x0+[cumsum([0;dx]+dxrandom)];
movable.x = x - x(1) + mean(fixed.x(1:2));

% Next, the kernel function and SPH parameters are defined.
% The kernel function is used to calculate the smoothing function
% for the SPH method, and the parameters include the smoothing length (h),
% the density (rho), and the coefficients (c0 and q1) used in the Landshoff force calculation.
h = 2 * r;
dWdr = @(r) (r% initial position
v = 0.1; % velocity (arbitrary units)
dt = 0.1;
config = movable;
clf, hold on, axis equal
layerplot(fixed)
[hp,ha] = deal([]);
axis off
RECORD = true; % set it to true to record a video

% The code then enters a loop that simulates the movement of the particles over time.
% In each iteration, the position of the "movable" layer is shifted by a fixed amount
% along the x-axis, and the particles are then repacked along the y-axis to be as close
% as possible to the particles in the "fixed" layer. This is done using the "distance"
% and "iclosest" functions to find the closest particle in the "fixed" layer to each
% particle in the "movable" layer, and then adjusting the positions of the particles
% in the "movable" layer accordingly.
for it=1:350
    shift = dt * v;
    config.x = config.x + shift;
    % repack the top layer respectively to the fixed
    distance = @(i) sqrt((fixed.x-config.x(i)).^2 + (fixed.y-config.y(i)).^2);
    iclosest = arrayfun( @(i) find( distance(i)==min(distance(i)),1),1:config.n );
    distance2closest = sqrt((fixed.x(iclosest)-config.x).^2 + (fixed.y(iclosest)-config.y).^2);
    dtarget = fixed.R*2*(1-abs(randn(config.n,1)*0.01));
    contraction_required = 1-dtarget./distance2closest;
    config.x = config.x + (fixed.x(iclosest)-config.x) .* contraction_required;
    config.y = config.y + (fixed.y(iclosest)-config.y) .* contraction_required;

    %The Landshoff forces are then calculated using a nested loop that iterates
    % over all pairs of particles in both layers. The forces are calculated using
    % the kernel function and the Landshoff force formula, which includes the velocity
    % difference and distance between particles, as well as the SPH parameters
    id = [ fixed.id * ones(fixed.n,1); config.id * ones(config.n,1) ];
    xy = [fixed.x fixed.y; config.x config.y];
    vxy = [repmat([0 0],fixed.n,1); repmat([v 0],config.n,1)];
    n = fixed.n + config.n;
    [mu,nu] = deal(zeros(n,n));
    F = zeros(n,n,2);
    for i = 1:n
        for j = 1:n
            rij = xy(i,:)-xy(j,:);
            vij = vxy(i,:)-vxy(j,:);
            if dot(rij,vij)<0
                mu(i,j) = h * dot(rij,vij)/(dot(rij,rij)+0.01*h^2);
                nu(i,j) = (1/rho) * (-q1*c0*mu(i,j));
                rij_d = norm(rij);
                rij_n = rij/rij_d;
                F(i,j,:) = -nu(i,j)*dWdr(rij_d) * permute(rij_n,[1 3 2]);
            end
        end
    end
    Fbalance = squeeze(sum(F,2));
    f = sum(Fbalance.^2,2);
    fmedian = median(f);
    fmin = fmedian/50;
    fscale = 0.2*r/fmedian;

    %Finally, the forces are plotted as arrows on the particle plot using the "arrow" function,
    % and the plot is updated with each iteration. 
    start = xy;
    stop = start + Fbalance*fscale;
    start(fif ~isempty(hp), delete(hp); end
    if ~isempty(ha), delete(ha); end
    hp = layerplot(config);
    ha = [
        arrow(start,stop,'length',8,'BaseAngle',60,'Linewidth',2,'color',rgb('ForestGreen'),'Edgecolor',rgb('ForestGreen'))
        arrow(start,[stop(:,1) start(:,2)],'length',4,'BaseAngle',60,'color',rgb('Tomato'))
        arrow(start,[start(:,1) stop(:,2)],'length',4,'BaseAngle',60,'color',rgb('Tomato'),'EdgeColor',rgb('Tomato'))
    ];
    drawnow

   %If the "RECORD" flag is set to true, the plot is also recorded as a GIF using the "gif_add_frame" function.
   if RECORD
       gif_add_frame(gca,'landshoff.gif',15);
   end

end

%% Landshoff forces in a wakeflow
% INRAE\Olivier Vitrac - rev. 25/02/2023

% [ SYNOPSIS ] This code simulates the movement of particles in a wake flow,
% in which an obstacle is placed in front of a flow to create a wake downstream.
% The simulation includes particles in several layers, with particles in each
% layer connected by a force that is calculated based on the Landshoff force formula.
% The code uses the SPH (Smoothed Particle Hydrodynamics) method to simulate the motion
% of the particles and the arrows plotted on the particle plot indicate the forces
% between particles. The code also includes a GIF recording function to capture the
% animation of the particle movements and forces.

%% General definitions

% layout definitions and plot customized function
layercolors = struct( ...
    'fixed',rgb('DodgerBlue'),...
    'layer1',rgb('DeepSkyBlue'),...
    'layer2',rgb('Aqua'),...
    'layer3',rgb('PaleTurquoise'),...
    'obstacle',rgb('Crimson') ...
);
layerplot = @(X) viscircles([X.xy],X.R*ones(X.n,1),'color',layercolors.(X.tag));

% configuration functions
layercoord = @(X) transpose([
            linspace(-(X.dx+X.R*2)*(X.n-1)/2,(X.dx+X.R*2)*(X.n-1)/2,X.n)
            ones(1,X.n) * (X.y + X.dy)
            ]);
layersliding = @(X) ones(X.n,1)*X.slidingdirection;
layerredistribute = @(X,x0) x0+[cumsum([0;diff(X.xy(:,1))]+abs(randn(X.n,1))*X.R*0.25)];

% mathematical functions for managing bead displacements
imin = @(d) find(d==min(d),1,'first');
imin2 = @(d) find(d==min(d(d>min(d))),1,'first');
distance = @(xy) sqrt(sum(xy.^2,2));
dist2ref = @(ref,testxy) distance(ref.xy-testxy);
iclosest = @(ref,test) cellfun(@(testxy) imin(dist2ref(ref,testxy)),num2cell(test.xy,2));
iclosest2 = @(ref,test) cellfun(@(testxy) imin2(dist2ref(ref,testxy)),num2cell(test.xy,2));
distance2closest = @(ref,test) distance(ref.xy(iclosest(ref,test),:)-test.xy);
distance2closest2 = @(ref,test) distance(ref.xy(iclosest2(ref,test),:)-test.xy);
contractionfactor = @(ref,test) 1 - ref.R*2*(1-abs(randn(test.n,1)*0.02)) ./ distance2closest(ref,test);
contractionfactor2 = @(ref,test) 1 - ref.R*2*(1-abs(randn(test.n,1)*0.02)) ./ distance2closest(ref,test);
updatexy = @(ref,test) test.xy + (ref.xy(iclosest(ref,test),:)-test.xy) .* contractionfactor(ref,test);
updatexy2 = @(ref,test) test.xy + (ref.xy(iclosest2(ref,test),:)-test.xy) .* contractionfactor2(ref,test);
thermostat = @(v) v .*(1+randn(size(v))*0.04);

% bead size (r) 
r = 0.5;

% Kernel definitions
% The kernel function is used to calculate the smoothing function
% for the SPH method, and the parameters include the smoothing length (h),
% the density (rho), and the coefficients (c0 and q1) used in the Landshoff force calculation.
h = 2 * r;
dWdr = @(r) (r%% Fixed layer
fixed = struct( ...these particles are arbitrarily fixed
    'R',r, ... radius
    'n',32,... number of beads
    'xy',[],... coordinates
    'y',-r,... initial position
    'dx',1e-2,... distance between beads
    'dy',0,...
    'slidingdirection',[1 0],...
    'tag','fixed',...
    'id',0 ...
    );
fixed.xy = layercoord(fixed);
fixed.xy(:,1) = layerredistribute(fixed,0);
fixed.slidingdirection = layersliding(fixed);

%% Layer 1 (in contact with the fixed layer)
layer1 = struct( ...these particles are arbitrarily fixed
    'R',r, ... radius
    'n',16,... number of beads
    'xy',[],... coordinates
    'y',+r,... initial position
    'dx',1e-2,... distance between beads
    'dy',1e-2,...
    'slidingdirection',[1 0],...
    'tag','layer1',...
    'id',1 ...
    );
layer1.xy = layercoord(layer1);
layer1.xy(:,1) = layerredistribute(layer1,fixed.R);
layer1.slidingdirection = layersliding(layer1);


% %% Layer 2 (in contact with the fixed layer)
layer2 = struct( ...these particles are arbitrarily fixed
    'R',r, ... radius
    'n',14,... number of beads
    'xy',[],... coordinates
    'y',+2*r,... initial position
    'dx',1e-2,... distance between beads
    'dy',1e-2,...
    'slidingdirection',[1 0],...
    'tag','layer2',...
    'id',2 ...
    );
layer2.xy = layercoord(layer2);
layer2.xy(:,1) = layerredistribute(layer2,layer1.xy(3,1)-fixed.R);
layer2.slidingdirection = layersliding(layer2);

% %% Layer 3 (in contact with the fixed layer)
layer3 = struct( ...these particles are arbitrarily fixed
    'R',r, ... radius
    'n',12,... number of beads
    'xy',[],... coordinates
    'y',+3*r,... initial position
    'dx',1e-2,... distance between beads
    'dy',1e-2,...
    'slidingdirection',[1 0],...
    'tag','layer3',...
    'id',3 ...
    );
layer3.xy = layercoord(layer3);
layer3.xy(:,1) = layerredistribute(layer3,layer1.xy(4,1));
layer3.slidingdirection = layersliding(layer3);

%% obstacle (in contact with the fixed layer)
[i,j] = meshgrid(-1:1,-1:1); [i,j] = deal(i(:),j(:));
centers = [ 2*i + mod(j,2), sqrt(3)*j ]*r;
centers(sum(centers.^2,2)>1,:)=[];
obstacle = struct( ...these particles are arbitrarily fixed
    'R',r, ... radius
    'n',size(centers,1),... number of beads
    'xy',[
        centers(:,1)+fixed.xy(floor(fixed.n/2),1)+fixed.R*5-min(centers(:,1)), ...
        centers(:,2)+fixed.y+fixed.dy+fixed.R+r-min(centers(:,2))
        ],... coordinates
    'y',+r,... initial position
    'dx',0,... distance between beads
    'dy',0,...
    'slidingdirection',[
         0      1     % SW
         0      1     % W
         0.5    0.5   % NW
         1   -0.2        % SE
         NaN  NaN     % center
         0.5  -0.5    % NE
         0.5  -0.5    % E
         ],...
    'tag','obstacle',...
    'id',100 ...
    );

%% all fixed (for collision only)
allfixed = fixed;
allfixed.xy = [fixed.xy;obstacle.xy];
allfixed.slidingdirection = [fixed.slidingdirection;obstacle.slidingdirection];
allfixed.n = fixed.n + obstacle.n;

%% control (only for validating the design)
clf, axis equal, hold on
layerplot(fixed)
layerplot(layer1)
layerplot(layer2)
layerplot(layer3)
ho=layerplot(obstacle);


%% Dynamic plot

% initial position
v = 4*0.1; % velocity (arbitrary units)
dt = 0.1;
[config1,config2,config3]  = deal(layer1, layer2, layer3);
clf, hold on, axis equal
layerplot(fixed);
ho=layerplot(obstacle);
[hp,ha] = deal([],{});
ax = axis;
axis off
RECORD = false; % set it to true to record a video

% The code then enters a loop that simulates the movement of the particles over time.
for it=1:800
    % layer2 neighbor
    ineigh12 = iclosest(config1,config2);
    ineigh13 = iclosest(config1,config3);
    % move of layer 1
    vshift1 = thermostat(v * allfixed.slidingdirection(iclosest(allfixed,config1),:));
    vshift1 = distance(v)*vshift1./distance(vshift1);
    shift1 = dt * vshift1;
    lastxy1 = config1.xy;
    config1.xy = config1.xy + shift1;
    alternativexy = updatexy2(allfixed,config1); % only alternative point
    config1.xy = updatexy(allfixed,config1);
    realdisplacement1 = distance(config1.xy-lastxy1);
    istuck1 = realdisplacement1<0.01;
    if any(istuck1)
        config1.xy(istuck1,:) = alternativexy(istuck1,:);
    end
    % move of layer 2
    directionlayer1 = config1.xy-lastxy1./distance(config1.xy-lastxy1);
    vshift2 = thermostat(v * directionlayer1(iclosest(layer1,config2),:));
    shift1update = thermostat(config1.xy-lastxy1);
    shift2 = shift1update(ineigh12,:);
    vshift2 = shift2/dt;
    config2.xy = config2.xy + shift2;
    config2.xy = updatexy(config1,config2);

    % move of layer 3
    vshift3 = thermostat(v * directionlayer1(iclosest(layer1,config3),:));
    shift3 = shift1update(ineigh13,:);
    vshift3 = shift3/dt;
    config3.xy = config3.xy + shift3;
    config3.xy = updatexy(config2,config3);


    %The Landshoff forces are then calculated using a nested loop that iterates
    % over all pairs of particles in both layers. The forces are calculated using
    % the kernel function and the Landshoff force formula, which includes the velocity
    % difference and distance between particles, as well as the SPH parameters
    id = [ allfixed.id * ones(allfixed.n,1); config1.id * ones(config1.n,1); config2.id * ones(config2.n,1); config3.id * ones(config3.n,1)];
    xy = [allfixed.xy; config1.xy; config2.xy; config3.xy];
    vxy = [repmat([0 0],allfixed.n,1); vshift1; vshift2; vshift3];
    n = allfixed.n + config1.n + config2.n + + config3.n;
    [mu,nu] = deal(zeros(n,n));
    F = zeros(n,n,2);
    for i = 1:n
        for j = 1:n
            rij = xy(i,:)-xy(j,:);
            vij = vxy(i,:)-vxy(j,:);
            if dot(rij,vij)<0
                mu(i,j) = h * dot(rij,vij)/(dot(rij,rij)+0.01*h^2);
                nu(i,j) = (1/rho) * (-q1*c0*mu(i,j));
                rij_d = norm(rij);
                rij_n = rij/rij_d;
                F(i,j,:) = -nu(i,j)*dWdr(rij_d) * permute(rij_n,[1 3 2]);
            end
        end
    end
    Fbalance = squeeze(sum(F,2));
    f = sum(Fbalance.^2,2);
    flog = log(1+f);
    flogmedian = median(flog(flog>0));
    flogmin = flogmedian/100;
    flogscale = 2*r/flogmedian;
    
    %Finally, the forces are plotted as arrows on the particle plot using the "arrow" function,
    % and the plot is updated with each iteration. 
    start = xy;
    stop = start + Fbalance./distance(Fbalance).*flog*flogscale;
    start(flogif ~isempty(hp), delete(hp{1}), delete(hp{2}), delete(hp{3}), end
    if ~isempty(ha), delete(ha); end
    hp = {layerplot(config1); layerplot(config2); layerplot(config3)};
    ha = [
        arrow(start,stop,'length',4,'BaseAngle',60,'Linewidth',1,'color',rgb('ForestGreen'),'Edgecolor',rgb('ForestGreen'))
        %arrow(start,[stop(:,1) start(:,2)],'length',4,'BaseAngle',60,'color',rgb('Tomato'))
        %arrow(start,[start(:,1) stop(:,2)],'length',4,'BaseAngle',60,'color',rgb('Tomato'),'EdgeColor',rgb('Tomato'))
    ];
    axis(ax)
    drawnow

   %If the "RECORD" flag is set to true, the plot is also recorded as a GIF using the "gif_add_frame" function.
   if RECORD
       gif_add_frame(gca,'landshoff_obstacle.gif',15);
   end

end

% First template to retrieve Billy's paper 2 simulation data 
% rev. 2024/03/07

% 2024/03/07 implementation of reverse streamlines, streamline binning from their initial positions, subsampling
% 2024/03/12 implement bead along streamlines (bug:NaN and Inf not allowed.) 
%% path and metadata
originalroot = '/media/olivi/T7 Shield/Thomazo_V2';
if exist(originalroot,'dir')
    root = originalroot;
else
    root = fullfile(pwd,'smalldumps');
end

simfolder = ...
    struct(...
    'A1',struct('artificial',...
'Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz',...
    'Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz' ...
                ),...
    'A2',struct('artificial',...
'./Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_2.tar.gz' ...
    ),...
    'B1',struct('Morris',...
'./Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft.tar.gz' ...
    ),...
    'B2',struct('Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_1.tar.gz' ...
    ),...
    'B3',struct('Morris',...
'/Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_2_3.tar.gz' ...
    ) ...
    );

% selection (not change it if you do not have the full dataset/hard disk attached to your system)
config = 'A1';
viscosity = 'Morris';
sourcefolder= fullfile(root,rootdir(simfolder.(config).(viscosity)));
sourcefile = regexprep(lastdir(simfolder.(config).(viscosity)),'.tar.gz$','');
dumpfile = fullfile(sourcefolder,sourcefile);

%% extract information
X0 = lamdumpread2(dumpfile); % first frame
natoms = X0.NUMBER;
timesteps = X0.TIMESTEPS;
X1 = lamdumpread2(dumpfile,'usesplit',[],timesteps(2));
dt = (X1.TIME-X0.TIME)/(timesteps(2)-timesteps(1)); % integration time step
times = double(timesteps * dt); % in seconds 
atomtypes = unique(X0.ATOMS.type);
ntimesteps = length(timesteps);
T = X0.ATOMS.type;
natomspertype = arrayfun(@(t) length(find(T==t)),atomtypes);
[~,ind] = sort(natomspertype,'descend');
% Thomazo simulation details
fluidtype  = ind(1);
pillartype = ind(2);
walltype   = ind(3);
spheretype = ind(4);
coords = {'z','x','y'}; % to match Thomazo's movies
vcoords = cellfun(@(c) sprintf('v%s',c),coords,'UniformOutput',false);
% Simulation parameters
mbead = 4.38e-12; % kg
rho = 1000; % kg / m3 (density of the fluid)
Vbead = mbead/rho;

%% Estimate bead size from the first frame
% first estimate assuming that the bead is a cube
fluidxyz0 = X0.ATOMS{T==fluidtype,coords};
boxdims = X0.BOX(:,2) - X0.BOX(:,1);
Vbead_guess = prod(boxdims)/natoms;
rbead_guess = (3/(4*pi)*Vbead_guess)^(1/3);
cutoff = 3*rbead_guess;
[verletList,cutoff,dmin,config,dist] = buildVerletList(fluidxyz0,cutoff); %#ok
rbead = dmin/2;
s = 2*rbead; % separation distance
h = 2*s;     % smoothing length

%% load the frame closest to simulation time: tframe
% with the mini dataset, are available:
% 0.30s 0.40s 0.45s 0.50s 0.55s 0.60s 0.65s 0.70s 0.75s 0.80s 0.85s 0.90s 0.95s 1.00s 1.05s 1.10s 
tframe = 0.8; % s <-------------------- select time here 
iframe = nearestpoint(tframe,times); % closest index
Xframe = lamdumpread2(dumpfile,'usesplit',[],timesteps(iframe));
Xframe.ATOMS.isfluid = Xframe.ATOMS.type==fluidtype;
Xframe.ATOMS.ispillar = Xframe.ATOMS.type==pillartype;
Xframe.ATOMS.issphere = Xframe.ATOMS.type==spheretype;
Xframe.ATOMS.issolid = Xframe.ATOMS.type==spheretype | Xframe.ATOMS.type==pillartype;
fluidxyz = Xframe.ATOMS{Xframe.ATOMS.isfluid,coords};
fluidid = X0.ATOMS{Xframe.ATOMS.isfluid,'id'};
pillarxyz = Xframe.ATOMS{Xframe.ATOMS.ispillar,coords};
pillarid = X0.ATOMS{Xframe.ATOMS.ispillar,'id'};
spherexyz = Xframe.ATOMS{Xframe.ATOMS.issphere,coords};
sphereid = X0.ATOMS{Xframe.ATOMS.issphere,'id'};
solidxyz = Xframe.ATOMS{Xframe.ATOMS.issolid,coords};
solidid = X0.ATOMS{Xframe.ATOMS.issolid,'id'};
ztop = max(pillarxyz(:,3)); % pillar top

%% Interpolate velocity field at z = ztop
fluidbox = [ min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords})
    max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords}) ]';
fluidboxsize = double(diff(fluidbox,1,2)); % for control
% restrict interpolation to the viewbox
viewbox = fluidbox; viewbox(3,:) = [ztop-2*h ztop+2*h];
insideviewbox = true(height(Xframe.ATOMS),1);
for icoord = 1:3
    insideviewbox = insideviewbox ...
        & Xframe.ATOMS{:,coords{icoord}}>=viewbox(icoord,1) ...
        & Xframe.ATOMS{:,coords{icoord}}<=viewbox(icoord,2);
end
XYZ  = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.isfluid,coords}; % fluid kernel centers
vXYZ = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.isfluid,vcoords}; % velocity of fluid kernel centers
XYZs = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.issolid,coords};
% interpolation grid
nresolution = [1024 1024 1];
xw = linspace(viewbox(1,1),viewbox(1,2),nresolution(1));
yw = linspace(viewbox(2,1),viewbox(2,2),nresolution(1));
zw = ztop;
[Xw,Yw,Zw] = meshgrid(xw,yw,zw);
XYZgrid = [Xw(:),Yw(:),Zw(:)];
% grid neighbors for interpolation and discarding grid points overlapping solid
VXYZ  = buildVerletList({XYZgrid XYZ},1.2*h);  % neighbors = fluid particles
VXYZs = buildVerletList({XYZgrid XYZs},0.85*s); % neighbors = solid particles
icontactsolid = find(cellfun(@length,VXYZs)>0);
VXYZ(icontactsolid) = repmat({[]},length(icontactsolid),1);
% neighbors statistics for control
% example with grid points having 20 neighbors or less: plot(XYZgrid(nn<20,1),XYZgrid(nn<20,2),'o','markerfacecolor','k')
%{
    nn = cellfun(@length,VXYZ);
    [nnu,~,innu] = unique(nn);
    cnnu = accumarray(innu,nn,[],@length);
%}

% interpolation stuff
W = kernelSPH(h,'lucy',3); % kernel expression
v3XYZgrid = interp3SPHVerlet(XYZ,vXYZ,XYZgrid,VXYZ,W,Vbead);
vxXYZgrid = reshape(v3XYZgrid(:,1),size(Xw)); %vxXYZgrid(isnan(vxXYZgrid)) = 0;
vyXYZgrid = reshape(v3XYZgrid(:,2),size(Xw)); %vyXYZgrid(isnan(vyXYZgrid)) = 0;
vzXYZgrid = reshape(v3XYZgrid(:,3),size(Xw)); %vzXYZgrid(isnan(vzXYZgrid)) = 0;
vXYZgrid  = reshape(sqrt(sum(v3XYZgrid.^2,2)),size(Xw));

%% Plot (attention 2D)
figure, hold on
% velocity magnitude
imagesc(xw,yw,vXYZgrid)
axis tight, axis equal
% quiver configuration and plot
step = 8;
boundaries = [ nearestpoint(double(xw([1,end]))+fluidboxsize(1)/30*[1 -1],double(xw))
               nearestpoint(double(yw([1,end]))+fluidboxsize(2)/30*[1 -1],double(yw))
             ];
indxquiver = boundaries(1,1):step:boundaries(1,2);
indyquiver = boundaries(2,1):step:boundaries(2,2);
quiver(Xw(indxquiver,indyquiver),Yw(indxquiver,indyquiver), ...
          vxXYZgrid(indxquiver,indyquiver),vyXYZgrid(indxquiver,indyquiver), ...
        'color','k','LineWidth',1)
% streamline configuration and plot
boundaries = [ nearestpoint(double(xw([1,end]))+fluidboxsize(1)/30*[1 -1]*1.5,double(xw))
               nearestpoint(double(yw([1,end]))+fluidboxsize(2)/30*[1 -1]*1,double(yw))
             ];
step = step/2;
indxstreamline = boundaries(1,1):step:boundaries(1,2);
indystreamline = boundaries(2,1):step:boundaries(2,2);
nstreamlines = length(indxstreamline);
% streamlines from bottom to top
[startX,startY,startZ] = meshgrid(double(xw(indxstreamline)),double(yw(indystreamline(1))),double(ztop));
vertices = stream2(double(Xw),double(Yw),vxXYZgrid,vyXYZgrid,startX,startY);
xinitialposition = cellfun(@(v) v(1,1),vertices);
yinitialposition = cellfun(@(v) v(1,2),vertices);
xfinalposition = cellfun(@(v) v(end,1),vertices);
yfinalposition = cellfun(@(v) v(end,2),vertices);
yfinaldefaultposition = yfinalposition(find(~isnan(yfinalposition),1,'first'));
indclosestToInitial = nearestpoint(xfinalposition,xinitialposition);
isinterrupted = isnan(yfinalposition);
% Build the adjacency matrix the initial and final position
A = false(nstreamlines,nstreamlines); %initial x final positions
for i=1:nstreamlines
    if ~isnan(indclosestToInitial(i))
        A(i,indclosestToInitial(i)) = true;
    end
end
isreached = any(A,1);
% Missinf streamlines from top to bottom
[startX2,startY2,startZ2] = meshgrid(xinitialposition(~isreached),yfinaldefaultposition,double(ztop));
vertices2 = stream2(double(Xw),double(Yw),-vxXYZgrid,-vyXYZgrid,startX2,startY2);
% streamlines from top to bottom (for unreached positions)

% control plot
% figure, hold on
% colors = tooclear(parula(nstreamlines));
% for i=1:nstreamlines
%     if isinterrupted(i)
%         plot(vertices{i}(:,1),vertices{i}(:,2),'-','linewidth',2,'color',colors(i,:));
%     else
%         plot(vertices{i}(:,1),vertices{i}(:,2),'--','linewidth',2,'color',colors(i,:));
%         plot( [xinitialposition(i);xinitialposition(indclosestToInitial(i))],...
%               [yinitialposition(i);yfinaldefaultposition],...
%               '-','linewidth',2,'color',colors(i,:))
%     end
%     text(xinitialposition(i),yinitialposition(i),sprintf('%d',i),'fontsize',8,'fontweight','bold','HorizontalAlignment','center','VerticalAlignment','middle')
%     if isreached(i), col = 'blue'; else col = 'red'; end
%     text(xinitialposition(i),yfinaldefaultposition,sprintf('%d',i),'fontsize',8,'fontweight','bold','HorizontalAlignment','center','VerticalAlignment','middle','color',col)
% end

% Merge all streamlines and create flags
allvertices = [vertices,vertices2];
idvertices = [ones(1,length(vertices)),2*ones(1,length(vertices2))];
[xallvertices,ind] = sort(cellfun(@(v) v(1,1),allvertices),'ascend'); % mean(v(:,1),'omitnan')
allvertices = allvertices(ind);
idvertices = idvertices(ind);
allbroken = cellfun(@(v) any(isnan(v(:,1))),allvertices);
allcomplete = ~allbroken;
allup =  cellfun(@(v) v(2,2)>v(1,2),allvertices);
alldown = ~allup;

% Pick streamlines from binning
nbins = 80;
xbins = linspace(xinitialposition(1),xinitialposition(end),nbins); % desired bin centers
dxbins = xbins(2)-xbins(1); % bin width (for control)
% Binning for complete streamlines
ibinsall = nearestpoint(xbins,xallvertices); %interpleft(xallvertices,1:length(allvertices),xbins);
ibinsall = ibinsall(allcomplete(ibinsall)); % we keep complete
% extract the initial (0) and final (1) positions of up/down streamlines
isselected = false(1,length(allvertices)); isselected(ibinsall)=true;
x0up = cellfun(@(v) v(1,1),allvertices(isselected & allup));
x1up = cellfun(@(v) v(end,1),allvertices(isselected & allup));
x0down = cellfun(@(v) v(1,1),allvertices(isselected & alldown));
x1down = cellfun(@(v) v(end,1),allvertices(isselected & alldown));
xdeviation = cellfun(@(v) abs(v(1,1)-v(end,1)),allvertices(isselected)); % for control
% Binning from incomplete (broken) streamlines
% all bins required
xbins_broken = xbins(setdiff(1:nbins,nearestpoint(xallvertices(ibinsall),xbins)));
if isempty(x1down)
    valid_up = true(size(xbins_broken));
else
    valid_up = abs(x1down(nearestpoint(xbins_broken,x1down))-xbins_broken)>(0.5*dxbins);
end
if isempty(x1up)
    valid_down = true(size(xbins_broken));
else
    valid_down = abs(x1up(nearestpoint(xbins_broken,x1up))-xbins_broken)>(0.5*dxbins);
end
iupbroken = find(allup & allbroken);
xupbroken = xallvertices(iupbroken);
ibinsupbroken = iupbroken(nearestpoint(xbins_broken(valid_up),xupbroken));
idownbroken = find(alldown & allbroken);
xdownbroken = xallvertices(idownbroken);
ibinsdownbroken = idownbroken(nearestpoint(xbins_broken(valid_down),xdownbroken));
% Merge and sort all bins
ibins = unique([ibinsall,ibinsdownbroken,ibinsupbroken]);

% check for holes/gaps between streamlines and overlopping streamlines
% The two passes are sequenced to avoid an infinite loop between fill/remove steps
% pass 1: fill the gaps (bottom and top) iteratively
% pass 1: remove ovelaps (bottom and top) iteratively (this step is always after the first filling procedure)
% pass 2: fill the gaps (bottom and top)
[holechecked, overlapchecked] = deal(false);
gapthreshmax = 1.9; % max gap (1=bin distance)
gapthreshmin = 0.5; % minimum gap
iter = 0; maxiter = 100;
pass2 = false;
while (~holechecked || ~overlapchecked) && iterend,1),allvertices(ispicked & allcomplete & alldown)));
    dxbottom = diff(xbottom)/dxbins;
    if any(dxbottom>gapthreshmax) && ~holechecked
        xholebottom = xallvertices(ibins(nearestpoint(xbottom(dxbottom>gapthreshmax),xallvertices(ibins))))+dxbins;
        iup = find(allup);
        ibinsholebottom = iup(nearestpoint(xholebottom,xallvertices(allup)));
        ibins = union(ibins,ibinsholebottom);
        holecheckbottom = false;
        overlapcheckbottom = false;
        dispf('add %d streamlines to the bottom',length(ibinsholebottom))
    elseif ~holechecked
        holecheckbottom = true;
    elseif any(dxbottomremove %d streamlines from the bottom',length(ioverlapbottom))
    else
         overlapcheckbottom = true;
    end
    ispicked = false(1,length(allvertices)); ispicked(ibins)=true;
    xtop = union(   cellfun(@(v) v(end,1),allvertices(ispicked & allcomplete & allup)),...
                    cellfun(@(v) v(1,1),allvertices(ispicked & alldown)));
    dxtop = diff(xtop)/dxbins;
    if any(dxtop>gapthreshmax) && ~holechecked
        xholetop = xallvertices(ibins(nearestpoint(xtop(dxtop>gapthreshmax),xallvertices(ibins))))+dxbins;
        idown = find(alldown);
        ibinsholetop = idown(nearestpoint(xholetop,xallvertices(alldown)));
        ibins = union(ibins,ibinsholetop);
        holechecktop = false;
        overlapchecktop = false;
        dispf('add %d streamlines to the top',length(ibinsholetop))
    elseif ~holechecked
        holechecktop = true;
    elseif any(dxtopremove %d streamlines from the top',length(ioverlaptop))
    else
        overlapchecktop = true;
    end
    holechecked = holecheckbottom && holechecktop;
    overlapchecked = overlapcheckbottom && overlapchecktop;
    if overlapchecked && ~pass2
        pass2=true;
        holechecked = false; % we restart the filling gap correction
    end
end
if iter>=maxiter, error('Gaps cannot be filled, decrease step (current=%d) !', step), end

% plot streamlines
hsl = streamline(allvertices); set(hsl,'linewidth',0.1,'color',[0.8 0.8 0.8]);
hsl = streamline(allvertices(ibins)); set(hsl,'linewidth',2,'color',[0.4375    0.5000    0.5625])
plot(startX(:),startY(:),'ro','markerfacecolor',[0.4375    0.5000    0.5625])


%% put beads along selected streamlines 
% get informations of streamlines
sl = allvertices(ibins);
nsl = length(sl); % number of selected streamlines
sall = cell(1,nsl);
for i=1:nsl
    csl = sl{i}; % select current streamline
    xcsl = csl(:,1); ycsl = csl(:,2);
    Tcsl = [diff(xcsl) diff(ycsl); NaN NaN];
    Tcsl_norm = Tcsl./sqrt(sum(Tcsl.^2,2));
    lcsl = [0; cumsum(sqrt(sum(Tcsl(1:end-1,:).^2,2)))];
    Vxcsl = interp2(Xw,Yw,vxXYZgrid,xcsl,ycsl);
    Vycsl = interp2(Xw,Yw,vyXYZgrid,xcsl,ycsl);
    Vcsl = [Vxcsl,Vycsl];
    Vlcsl = dot(Vcsl,Tcsl_norm,2);
    s = table(xcsl,ycsl,lcsl,Tcsl_norm,Vcsl,Vlcsl,'VariableNames',["x","y","l","T","V","Vl"]);
    sall{i} = s;
end
% put beads
dt = 0.01;
figure, hold on
for i=1:nsl
    [x,y,Vl,l] = add_bead(sall{i},rbead,dt);
    centers = [x,y];
    viscircles(centers,rbead)
end

% First template to retrieve Billy's paper 2 simulation data 
% rev. 2024/03/17 - forked in 2024/03/16 with PBC

% 2024/03/07 implementation of reverse streamlines, streamline binning from their initial positions, subsampling
% 2024/03/12 implement bead along streamlines (bug:NaN and Inf not allowed.) 
% 2024/03/16 fork from Billy_results_template.m (MAJOR UPDATE)
% 2024/03/17 release candidate
% 2024/03/21 preproduction on minidump
% 2024/03/24 major update: full implementation of density correction and force contours around objects
% 2024/03/24 selective copy possible if originalroot is made available
% 2024/03/24 add prefetch management
% 2024/03/25 first batch of preproduction tframe 0.3->1.1 (step 0.01)
% 2024/03/26 second batch of preproduction tframe 0.11->0.4 (step 0.01)
% 2024/03/27 fix streamlines when less than one bead must be added (tframe = 0.11 and 0.27)
% 2024/03/27 fix contour, tangents/normals, add perssure
% 2024/03/27 Senstivity challenge test using ngenerations = 8 and xshift = double(mod(igen-1,2)*(xwPBC(indxstreamline(2))-xwPBC(indxstreamline(1))));
% 2024/03/30 full implementation of Landshoff forces
% 2024/03/31 add FLAGS, documentation and save results capability (R0 and R1 for original and informed results, respectively) 
% 2024/03/31 full rewritting of PLOT capabilities to use exclusively R0 and R1 for plotting

% SUMMARY

% This MATLAB script is a comprehensive framework for analyzing fluid dynamics simulations, specifically focusing on the distribution and movement of particles or beads in a fluid environment. Key functionalities include:
% 
% 1. Environment Setup:
%   Initializes the simulation environment by clearing variables, setting up output folders, and defining file paths to simulation data, with adjustments for periodic boundary conditions (PBC).
% 2. Data Retrieval:
%   Loads simulation data from specified file paths, handling different configurations and viscosity models.
% 3. Simulation Analysis:
%   Processes the simulation data to calculate parameters such as bead sizes, timestep intervals, and spatial distributions of particles.
% 4. Frame Selection:
%   Identifies simulation frames for detailed analysis based on time criteria, with capabilities to adjust for available data subsets.
% 5. Velocity Field and Density Calculation:
%   Computes the velocity field at a specific plane in the simulation domain and estimates the local density of particles.
% 6. Streamline and Bead Distribution Analysis:
%   Generates streamlines and distributes beads along these lines, incorporating PBC adjustments to simulate continuous fluid flow across boundaries.
% 7. Overlap Removal:
%   Implements algorithms to remove overlapping beads based on their spatial proximity and streamline generation, ensuring a realistic particle distribution.
% 8. Density Filtering:
%   Filters out beads in regions of excessively high simulated density to adhere to physical constraints.
% 9. Contact Detection with Objects:
%   Identifies beads in contact with solid objects within the simulation, leveraging density information to infer interaction dynamics.
% 10. Visual Representation:
%   Provides extensive plotting capabilities to visualize various aspects of the simulation, including velocity fields, bead distributions, and pressure around objects, with options to export figures.


%% Definitions (it is a script accepting ONE variable and FLAGS)
%
%   List of of variables
%           tframe <-- use this variable a in for-loop or choose a particular frame before calling this script
%       tframelist (not used)
%
%   List of available FLAGS
%       RESETPREFETCH forces all prefetch files to be regenerated in true (default=false)
%              PLOTON enables to plot results (default=true)
%             PRINTON prints figures as PNG images for control (in outputfolder) (default=false)
%              SAVEON saves the results R0 (original), R1 (informed) (default=true)
%           OVERWRITE enables already saved results to overwritte (default=false)

% close, delete everything except variables and FLAGS
clc
close all
clearvars -except tframe tframelist RESETPREFETCH PLOTON PRINTON SAVEON OVERWRITE
t0_ = clock;

% check folders
outputfolder = fullfile(pwd,'preproduction');
savefolder = fullfile(pwd,'results');
prefetchfolder = fullfile(pwd,'prefetch');
if ~exist(outputfolder,'dir'), mkdir(outputfolder); end
if ~exist(prefetchfolder,'dir'), mkdir(prefetchfolder); end
if ~exist(savefolder,'dir'), mkdir(savefolder); end

% Assign default values if needed
if ~exist('RESETPREFETCH','var'), RESETPREFETCH = false; end
if ~exist('PLOTON','var'), PLOTON = true; end
if ~exist('PRINTON','var'), PRINTON = false; end
if ~exist('SAVEON','var'), SAVEON = true; end
if ~exist('OVERWRITE','var'), OVERWRITE = false; end

% Anonymous functions
prefetchvar = @(varargin) fullfile(prefetchfolder,sprintf('t%0.4f_%s.mat',tframe,varargin{1}));
isprefetch = @(varargin) exist(prefetchvar(varargin{1}),'file') && ~RESETPREFETCH;
dispsection = @(s) dispf('\n%s\ntframe=%0.4g s \t[  %s  ]   elapsed time: %4g s\n%s',repmat('*',1,120),tframe,regexprep(upper(s),'.','$0 '),etime(clock,t0_),repmat('*',1,120)); %#ok
fighandle = @(id) formatfig(figure,'figname',sprintf('t%0.3g_%s',tframe,id));
printhandle = @(hfig) print_png(300,fullfile(outputfolder,[get(hfig,'filename') '.png']),'','',0,0,0);

% results saved in two variables to avoid any confusion
R0 = struct([]); % reference data
R1 = struct([]);  % informed ones

%% path and metadata
dispsection('INITIALIZATION')
originalroot = '/media/olivi/T7 Shield/Thomazo_V2';
if exist(originalroot,'dir')
    root = originalroot;
    rootlocal = fullfile(pwd,'smalldumps');
    copymode = true;
else
    root = fullfile(pwd,'smalldumps');
    copymode = false;
end

simfolder = ...
    struct(...
    'A1',struct('artificial',...
'Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz',...
    'Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz' ...
                ),...
    'A2',struct('artificial',...
'./Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_2.tar.gz' ...
    ),...
    'B1',struct('Morris',...
'./Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft.tar.gz' ...
    ),...
    'B2',struct('Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_1.tar.gz' ...
    ),...
    'B3',struct('Morris',...
'/Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_2_3.tar.gz' ...
    ) ...
    );

% selection (not change it if you do not have the full dataset/hard disk attached to your system)
config = 'A1';
viscosity = 'Morris';
sourcefolder= fullfile(root,rootdir(simfolder.(config).(viscosity)));
sourcefile = regexprep(lastdir(simfolder.(config).(viscosity)),'.tar.gz$','');
dumpfile = fullfile(sourcefolder,sourcefile);
dispf('config: %s | viscosity: %s | source: %s',config,viscosity,dumpfile)

%% extract information
dispsection('OVERVIEW')
X0 = lamdumpread2(dumpfile); % first frame
natoms = X0.NUMBER;
timesteps = X0.TIMESTEPS;
X1 = lamdumpread2(dumpfile,'usesplit',[],timesteps(2));
dt = (X1.TIME-X0.TIME)/(timesteps(2)-timesteps(1)); % integration time step
times = double(timesteps * dt); % in seconds 
atomtypes = unique(X0.ATOMS.type);
ntimesteps = length(timesteps);
T = X0.ATOMS.type;
natomspertype = arrayfun(@(t) length(find(T==t)),atomtypes);
[~,ind] = sort(natomspertype,'descend');
% Thomazo simulation details
fluidtype  = ind(1);
pillartype = ind(2);
walltype   = ind(3);
spheretype = ind(4);
coords = {'z','x','y'}; % to match Thomazo's movies
vcoords = cellfun(@(c) sprintf('v%s',c),coords,'UniformOutput',false);
icoords = cellfun(@(c) find(ismember({'x','y','z'},c)),coords); %<- use this index for BOX
% Simulation parameters
% Billy choose a reference density of 900 kg/m3 for a physical density of 1000 kg/m3
% Viscosity: 0.13 Pa.s
mbead = 4.38e-12; % kg
rho = 1000; % kg / m3 (density of the fluid)
Vbead = mbead/rho;
dispf('SUMMARY: natoms: %d | dt: %0.3g s | rho: %0.4g',natoms,dt,rho)

%% selective copy of PREFETCH files (if possible)
if copymode
    dispsection('COPY')
    myprefetchfile = @(itime) sprintf('%s%09d.mat','TIMESTEP_',itime);
    myprefetchfolder = @(d) fullfile(d,sprintf('PREFETCH_%s',lastdir(dumpfile)));
    destinationfolder = fullfile(rootlocal,rootdir(simfolder.(config).(viscosity)));
    sourcefolderPREFETCH = myprefetchfolder(sourcefolder);
    destinationfolderPREFETCH = myprefetchfolder(destinationfolder);
    % Choose the frames needed here
    tcopy = 0.0:0.01:1.2;
    % files to copy
    tfile = arrayfun(@(t) myprefetchfile(t), timesteps(unique(nearestpoint(tcopy,times))),'UniformOutput',false);
    oksource = all(cellfun(@(f) exist(fullfile(sourcefolderPREFETCH,f),'file'),tfile));
    if ~oksource, error('the source folder is corrupted, please check'), end
    existingfiles = cellfun(@(f) exist(fullfile(destinationfolderPREFETCH,f),'file'),tfile);
    dispf('Number of files to copy: %d (%d already available)',length(find(~existingfiles)),length(find(existingfiles)))
    copysuccess = cellfun(@(f) copyfile(fullfile(sourcefolderPREFETCH,f),fullfile(destinationfolderPREFETCH,f)),tfile(~existingfiles));
    dispf('%d of %d files have been copied',length(find(copysuccess)),length(copysuccess));
end

%% Estimate bead size from the first frame
% first estimate assuming that the bead is a cube
dispsection('BEAD SIZE')
fluidxyz0 = X0.ATOMS{T==fluidtype,coords};
boxdims = X0.BOX(:,2) - X0.BOX(:,1);
Vbead_guess = prod(boxdims)/natoms;
rbead_guess = (3/(4*pi)*Vbead_guess)^(1/3);
cutoff = 3*rbead_guess;
if isprefetch('verletList')
    load(prefetchvar('verletList'))
else
    [verletList,cutoff,dmin,config,dist] = buildVerletList(fluidxyz0,cutoff);
    save(prefetchvar('verletList'),'verletList','cutoff','dmin','config','dist')
end
rbead = dmin/2;
s = 2*rbead; % separation distance
h = 2*s;     % smoothing length
dispf('SUMMARY: s: %0.4g m | h: %0.4g m',s,h)
%% load the frame closest to simulation time: tframe
% with the mini dataset, are available:
% 0.30s 0.40s 0.45s 0.50s 0.55s 0.60s 0.65s 0.70s 0.75s 0.80s 0.85s 0.90s 0.95s 1.00s 1.05s 1.10s 
% tframelist = [0.3 0.4 0.45:0.05:1.10]; % verysmalldumps
tframelist = 0.0:0.01:1.2; % updated time frames
if ~exist('tframe','var')
    tframe = 0.85; %0.55; % s <-------------------- select time here
else
    tframe = tframelist(nearestpoint(tframe,tframelist)); % restrict to existing tframes
end
iframe = nearestpoint(tframe,times); % closest index
Xframe = lamdumpread2(dumpfile,'usesplit',[],timesteps(iframe));
Xframe.ATOMS.isfluid = Xframe.ATOMS.type==fluidtype;
Xframe.ATOMS.ispillar = Xframe.ATOMS.type==pillartype;
Xframe.ATOMS.issphere = Xframe.ATOMS.type==spheretype;
Xframe.ATOMS.issolid = Xframe.ATOMS.type==spheretype | Xframe.ATOMS.type==pillartype;
fluidxyz = Xframe.ATOMS{Xframe.ATOMS.isfluid,coords};
fluidid = X0.ATOMS{Xframe.ATOMS.isfluid,'id'};
pillarxyz = Xframe.ATOMS{Xframe.ATOMS.ispillar,coords};
pillarid = X0.ATOMS{Xframe.ATOMS.ispillar,'id'};
spherexyz = Xframe.ATOMS{Xframe.ATOMS.issphere,coords};
sphereid = X0.ATOMS{Xframe.ATOMS.issphere,'id'};
solidxyz = Xframe.ATOMS{Xframe.ATOMS.issolid,coords};
solidid = X0.ATOMS{Xframe.ATOMS.issolid,'id'};
ztop = max(pillarxyz(:,3)); % pillar top

% Definitions based on actual tframe
dispsection = @(s) dispf('\n%s\ntframe=%0.4g s \t[  %s  ]   elapsed time: %4g s\n%s',repmat('*',1,120),tframe,regexprep(upper(s),'.','$0 '),etime(clock,t0_),repmat('*',1,120)); %#ok
prefetchvar = @(varargin) fullfile(prefetchfolder,sprintf('t%0.4f_%s.mat',tframe,varargin{1}));
isprefetch = @(varargin) exist(prefetchvar(varargin{1}),'file') && ~RESETPREFETCH;
savefile = @() fullfile(savefolder,sprintf('Rt.%0.4f.mat',tframe));


%% Interpolate velocity field at z = ztop
dispsection('REFERENCE VELOCITY FIELD')
% full box (note that atoms may be outside of this box)
box = Xframe.BOX(icoords,:); % note that the order is given by coords, here {'z'}    {'x'}    {'y'}
boxsize = diff(box,1,2);
% fluidbox (box for atoms to consider)
xmin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{1}});
xmax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{1}});
ymin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{2}});
ymax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{2}});
zmin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{3}});
zmax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{3}});
fluidbox = [xmin xmax;ymin ymax;zmin zmax];
% restrict interpolation to the viewbox
viewbox = fluidbox; viewbox(3,:) = [ztop-2*h ztop+2*h];
insideviewbox = true(height(Xframe.ATOMS),1);
for icoord = 1:3
    insideviewbox = insideviewbox ...
        & Xframe.ATOMS{:,coords{icoord}}>=viewbox(icoord,1) ...
        & Xframe.ATOMS{:,coords{icoord}}<=viewbox(icoord,2);
end
XYZ  = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.isfluid,coords};  % fluid kernel centers
vXYZ = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.isfluid,vcoords}; % velocity of fluid kernel centers
XYZs = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.issolid,coords};  % solid kernel centers
rhobeadXYZ = Xframe.ATOMS.c_rho_smd(insideviewbox & Xframe.ATOMS.isfluid); % volume of the bead

% force incell (this step is needed to apply PBC)
XYZ = PBCincell(XYZ,box,[true,true,false]);
XYZs = PBCincell(XYZs,box,[true,true,false]);

% add PBC images
[XYZimagesONLY ,indXimagesONLY]= PBCimages(XYZ,box,[true,true,false],2*h);
XYZwithImages = [XYZ;XYZimagesONLY];
vXYZwithImages = [vXYZ;vXYZ(indXimagesONLY,:)];
rhobeadXYZwithImages = [rhobeadXYZ;rhobeadXYZ(indXimagesONLY)];
VbeadXYZwithImages = mbead./rhobeadXYZwithImages;
isImages = true(size(XYZwithImages,1),1); isImages(1:size(XYZ,1))=false;

% Plot PBC (plot saved in R0) 
R0(1).XYZ = XYZ;
R0(1).indXimagesONLY = indXimagesONLY;
R0(1).XYZimagesONLY = XYZimagesONLY;
if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R0) **********
    figure, hold on, plot3D(XYZ,'go')
    plot3D(R0(1).XYZ(R0(1).indXimagesONLY,:),'go','markerfacecolor','g')
    plot3D(R0(1).XYZimagesONLY,'ro','markerfacecolor','r'), view(3), axis equal, view(2)
end


% interpolation grid (central grid, no images)
nresolution = [1024 1024 1];
xw = linspace(box(1,1),box(1,2),nresolution(1));
yw = linspace(box(2,1),box(2,2),nresolution(1));
zw = ztop;
[Xw,Yw,Zw] = meshgrid(xw,yw,zw);
XYZgrid = [Xw(:),Yw(:),Zw(:)];

% grid neighbors (incl. images) for interpolation and discarding grid points overlapping solid
if isprefetch('VXYZ')
    load(prefetchvar('VXYZ'))
else
    VXYZ  = buildVerletList({XYZgrid XYZwithImages},1.2*h);  % neighbors = fluid particles
    VXYZs = buildVerletList({XYZgrid XYZs},0.85*s); % neighbors = solid particles
    save(prefetchvar('VXYZ'),'VXYZ','VXYZs')
end
icontactsolid = find(cellfun(@length,VXYZs)>0);
VXYZ(icontactsolid) = repmat({[]},length(icontactsolid),1);

% interpolation on the grid of the 3D velocity (central grid)
% Do not forget even if we are applying a 2D interpretation, we use a 3D simulation
% 3D velocity are projected on 2D streamlines even if the projection of the 3rd component is 0
W = kernelSPH(h,'lucy',3); % kernel expression
if isprefetch('v3XYZgrid')
    load(prefetchvar('v3XYZgrid'))
else
    v3XYZgrid = interp3SPHVerlet(XYZwithImages,vXYZwithImages,XYZgrid,VXYZ,W,VbeadXYZwithImages);
    save(prefetchvar('v3XYZgrid'),'v3XYZgrid')
end
vxXYZgrid = reshape(v3XYZgrid(:,1),size(Xw)); %vxXYZgrid(isnan(vxXYZgrid)) = 0;
vyXYZgrid = reshape(v3XYZgrid(:,2),size(Xw)); %vyXYZgrid(isnan(vyXYZgrid)) = 0;
vzXYZgrid = reshape(v3XYZgrid(:,3),size(Xw)); %vzXYZgrid(isnan(vzXYZgrid)) = 0;
vXYZgrid  = reshape(sqrt(sum(v3XYZgrid.^2,2)),size(Xw));

% density on the grid (with a possible different h)
if isprefetch('rhobeadXYZgrid')
    load(prefetchvar('rhobeadXYZgrid'))
else
    rhobeadXYZgrid = interp3SPHVerlet(XYZwithImages,rhobeadXYZwithImages,XYZgrid,VXYZ,W,VbeadXYZwithImages);
    save(prefetchvar('rhobeadXYZgrid'),'rhobeadXYZgrid')
end
rhobeadXYZgrid = reshape(rhobeadXYZgrid,size(Xw));

% add PBC (add periodic PBC)
[vxXYZPBC,XwPBC,YwPBC] = PBCgrid(Xw,Yw,vxXYZgrid,[true,true],boxsize(1:2)./[8;2]);
rhobeadXYZPBC = PBCgrid(Xw,Yw,rhobeadXYZgrid,[true,true],boxsize(1:2)./[8;2]);
xwPBC = XwPBC(1,:); ywPBC = YwPBC(:,1)';
fluidboxPBC = double([xwPBC([1 end]);ywPBC([1 end]);fluidbox(3,:)]);
fluidboxsizePBC = diff(fluidboxPBC,1,2);
vyXYZPBC = PBCgrid(Xw,Yw,vyXYZgrid,[true,true],boxsize(1:2)./[8;2]);
vzXYZPBC = PBCgrid(Xw,Yw,vzXYZgrid,[true,true],boxsize(1:2)./[8;2]);
vXYZPBC = sqrt(vxXYZPBC.^2 + vyXYZPBC.^2 + vzXYZPBC.^2);

% Plot PBC (saved in R0)
R0(1).fluidboxPBC = fluidboxPBC;
R0(1).fluidboxsizePBC = fluidboxsizePBC;
R0(1).xwPBC = xwPBC;
R0(1).ywPBC = ywPBC;
R0(1).XwPBC = XwPBC;
R0(1).YwPBC = YwPBC;
R0(1).vxXYZPBC = vxXYZPBC;
R0(1).vyXYZPBC = vyXYZPBC;
R0(1).vXYZPBC = vXYZPBC;
R0(1).rhobeadXYZPBC = rhobeadXYZPBC;
R0(1).rhobeadXYZgrid = rhobeadXYZgrid;
if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R0) **********
    figure, mesh(R0(1).XwPBC,R0(1).YwPBC,R0(1).vXYZPBC), axis equal, view(2), colorbar, title(sprintf('t=%0.3f s - velocity (m/s)',tframe))
    figure, mesh(R0(1).XwPBC,R0(1).YwPBC,R0(1).rhobeadXYZPBC); axis equal, view(2), colorbar, title(sprintf('t=%0.3f s - density (kg/m3)',tframe))
end

%% Plot (attention 2D, meshgrid convention)
if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R0) **********
    figure, hold on
    % velocity magnitude
    imagesc(R0(1).xwPBC,R0(1).ywPBC,R0(1).vXYZPBC)
    axis tight, axis equal
    colorbar
    title(sprintf('t=%0.3f s - velocity (m/s)',tframe))
    
    % quiver configuration and plot (boundaries are with PBC)
    stepPBC = 16;
    boundariesPBC = ...
                 [ nearestpoint(double(R0(1).xwPBC([1,end]))+R0(1).fluidboxsizePBC(1)/100*[1 -1],double(R0(1).xwPBC)) % x
                   nearestpoint(double(R0(1).ywPBC([1,end]))+R0(1).fluidboxsizePBC(2)/100*[1 -1],double(R0(1).ywPBC)) % y
                 ];
    indxquiver = boundariesPBC(1,1):stepPBC:boundariesPBC(1,2); % x indices
    indyquiver = boundariesPBC(2,1):stepPBC:boundariesPBC(2,2); % y indices
    quiver(R0(1).XwPBC(indyquiver,indxquiver),R0(1).YwPBC(indyquiver,indxquiver), ...
              R0(1).vxXYZPBC(indyquiver,indxquiver),R0(1).vyXYZPBC(indyquiver,indxquiver), ...
            'color','k','LineWidth',1)
end

%% streamlines
dispsection('STREAMLINES')
% UP from bottom (starting position) to top
% DOWN from top to bottom (same starting position by reversing the velocity field)
% assembled as [flipud(DOWN(2:end,:));UP]
% CELL streamlines along a y period, the separation distance is added to avoid gap

% streamline configuration and plot
boundaries = [ nearestpoint(double(xw([1,end])),double(xwPBC))
               nearestpoint(double(yw([1,end])),double(ywPBC))
             ];
step = 8;
indxstreamline = boundaries(1,1):step:boundaries(1,2);
indystreamline = boundaries(2,1):step:boundaries(2,2);
nstreamlines = length(indxstreamline);

% Generative streamlines
ngenerations = 4;
xshift = 0.0;
iygen = unique(round(linspace(indystreamline(1),indystreamline(end),ngenerations)));
ngenerations = length(iygen);
[verticesgenUP,verticesgenDOWN,verticesgen,verticesgenCELL,verticesgenCELLid] = deal({});
validstreamline = @(v) (v(:,2)-v(1,2))<=(boxsize(2)*1.5) & (v(:,2)-v(1,2))>=(boxsize(2)*0.01); % longer than 1% but not exceeding 150%
for igen = 1:ngenerations
    % ith generation of stream line (from indystreamline(1))
    dispf('generate the %dth of %d generation of streamlines',igen,ngenerations)
    %xshift = double(mod(igen-1,2)*(xwPBC(indxstreamline(2))-xwPBC(indxstreamline(1))));
    [startgenX,startgenY,startgenZ] = meshgrid(...
        double(xwPBC(indxstreamline))+xshift,...
        double(ywPBC(iygen(igen))),double(ztop));
    verticesgenUP{igen} = stream2(double(XwPBC),double(YwPBC),vxXYZPBC,vyXYZPBC,startgenX,startgenY,[0.03 5e4]);
    verticesgenDOWN{igen} = stream2(double(XwPBC),double(YwPBC),-vxXYZPBC,-vyXYZPBC,startgenX,startgenY,[0.03 5e4]);
    verticesgen{igen} = cellfun(@(d,u) [flipud(d(2:end,:)); u],verticesgenDOWN{igen},verticesgenUP{igen},'UniformOutput',false);
    verticesgen{igen} = cellfun(@(v) v(~isnan(v(:,2)),:),verticesgen{igen},'UniformOutput',false);
    verticesgenCELL{igen} = cellfun(@(v) v(validstreamline(v),:),verticesgen{igen},'UniformOutput',false);
    verticesgenCELLid{igen} = igen*ones(1,length(verticesgenCELL{igen}));
end

% merge all verticesCELL
verticesCELL = cat(2,verticesgenCELL{:});
verticesCELLid = cat(2,verticesgenCELLid{:});
okverticesCELL = cellfun(@length,verticesCELL)>100; % remove empty and too short streamlines (as a result of filtering by validstreamline)
verticesCELL = verticesCELL(okverticesCELL);
verticesCELLid = verticesCELLid(okverticesCELL);

% retrieve the separation distance
sLagrangian = startgenX(1,2,1) - startgenX(1,1,1); % separation distance between streamlines at injection/starting
rLagrangian = sLagrangian/2;


% detect interruption (for control)
% yfinalposition1UP = cellfun(@(v) v(end,2),vertices1UP);
% yfinalposition1DOWN = cellfun(@(v) v(end,2),vertices1DOWN);
% isinterrupted1 = isnan(yfinalposition1UP) | isnan(yfinalposition1DOWN);

% control plot (saved in R1, partial with decimation)
R1(1).box = box;
R1(1).sLagrangian = sLagrangian;
R1(1).rLagrangian = rLagrangian;
R1(1).ngenerations = ngenerations;
R1(1).nstreamlines = nstreamlines;
R1(1).verticesgen = cell(size(verticesgen));
R1(1).verticesgenCELL = cell(size(verticesgenCELL));
decimation = 100;
for igen = 1:ngenerations
    R1(1).verticesgen{igen} = cell(size(verticesgen{igen}));
    R1(1).verticesgenCELL{igen} = cell(size(verticesgenCELL{igen}));
    for i=1:nstreamlines
        R1(1).verticesgen{igen}{i} = verticesgen{igen}{i}(1:decimation:end,:); 
        R1(1).verticesgenCELL{igen}{i} = verticesgenCELL{igen}{i}(1:decimation:end,:); 
    end
end
if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R1) **********
    figure, hold on
    imagesc(R0(1).xwPBC,R0(1).ywPBC,R0(1).vXYZPBC)
    colors = jet(R1(1).ngenerations);
    
    for igen = 1:R1(1).ngenerations
        for i=1:R1(1).nstreamlines
            plot(R1(1).verticesgen{igen}{i}(:,1),R1(1).verticesgen{igen}{i}(:,2),'-','LineWidth',0.5,'color',colors(igen,:))
            plot(R1(1).verticesgenCELL{igen}{i}(:,1),R1(1).verticesgenCELL{igen}{i}(:,2),'-','linewidth',1,'color',colors(igen,:));
        end
    end
    axis equal
    title(sprintf('t=%0.3f s - streamlines',tframe))
end

%% Distribute beads along streamlines tagged as CELL
% Once PBC are applied, space is filled with possibly overlaping streamlines
% the control plot is showing this effect
dispsection('INFORMED BEADS')
traj = fillstreamline2(verticesCELL,XwPBC,YwPBC,vxXYZPBC,vyXYZPBC,rLagrangian,0);
ntraj = length(traj);
%trajUP = fillstreamline2(verticesUPCELL,XwPBC,YwPBC,vxXYZPBC,vyXYZPBC,rLagrangian,0);
%traj(~isinterrupted) = trajUP(~isinterrupted);
XYZbeads = arrayfun(@(t) t.cart_distribution,traj,'UniformOutput',false);
% we apply PBC while keeping the id of the streamline
[XYZbeadsPBC,XYZbeadsPBCid] = deal(cell(ntraj,1));
for itraj=1:ntraj % trajectories and streamlines are assumed equivalent at steady state
    XYZbeadsPBC{itraj} = PBCincell(XYZbeads{itraj},box(1:2,:),[true true]); % wrapping along PBC
    XYZbeadsPBCid{itraj} = ones(size(XYZbeadsPBC{itraj},1),1)*verticesCELLid(itraj);
end

% control plots (saved in R1)
R1(1).ntraj = ntraj;
R1(1).XYZbeadsPBC = XYZbeadsPBC;
R1(1).XYZbeadsPBCid = XYZbeadsPBCid;
if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R1) **********
    figure, hold on
    colors = tooclear(jet(R1(1).ntraj));
    for itraj = 1:R1(1).ntraj
        plot(R1(1).XYZbeadsPBC{itraj}(:,1),R1(1).XYZbeadsPBC{itraj}(:,2),'o',...
            'markerfacecolor',colors(itraj,:),'markeredgecolor',colors(itraj,:))
    end
    title(sprintf('t=%0.3f s - colors match streamline index',tframe))
    
    figure, hold on
    colors = tooclear(jet(R1(1).ngenerations));
    for itraj = 1:R1(1).ntraj
        plot(R1(1).XYZbeadsPBC{itraj}(:,1),R1(1).XYZbeadsPBC{itraj}(:,2),'o',...
            'markerfacecolor',colors(R1(1).XYZbeadsPBCid{itraj}(1),:),'markeredgecolor',colors(R1(1).XYZbeadsPBCid{itraj}(1),:))
    end
    title(sprintf('t=%0.3f s - colors match generation index',tframe))
end

%% remove duplicated beads between streamlines (too close)
% defined as beads from another streamline located at less than rbead
% this version incorporate the effect of the generational distance (somekind of age)
% beads from other injections points should emerge from positions farther from first generations (older ones)
% the generation index starts from the source of the flow (bottom), using streamlines from other positions is discouraged (since younger)
% 
% Note: streamlines are indexed from oldest (closest to the source) to youngest (farthest from the source)
dispsection('CLEAN OVERLAPPED BEADS')
% beads from different streamlines
for i=1:ntraj % reference streamline (higher precedence)
    for j=1:ntraj % the other streamline
        if i~=j
            indj = find(~isnan(XYZbeadsPBC{j}(:,1)));
            dij=pdist2(XYZbeadsPBC{i},XYZbeadsPBC{j}(indj,:)); % Euclidian distance
            % the criterion on age is too strict
            %dgenij = pdist2(XYZbeadsPBCid{i},XYZbeadsPBCid{j}(indj,:)); % generational distance (0 for the same generation)
            %XYZbeadsPBC{j}(indj(any(dij
            XYZbeadsPBC{j}(indj(any(dijend
    end
end

% beads from the same streamline
% two populations of beads are created (those inside and those outside (images) that could overlap those inside when they coordinates are wrapped)
%
% Note: we do not consider the overlapping of north and south images (the total height of a streamline is considered not to exceed 150% of the box height)
for i=1:ntraj
    isoutside =  (XYZbeads{i}(:,1)box(1,2)) | ...
                 (XYZbeads{i}(:,2)box(2,2) );
    isvalid = ~isnan(XYZbeadsPBC{i}(:,1));
    ioutside = find(isoutside & isvalid);  % these beads are possible images of beads already inside
    iinside =  find(~isoutside & isvalid); % these beads have higher precedence, they are already inside
    divsout=pdist2(XYZbeadsPBC{i}(iinside,:),XYZbeadsPBC{i}(ioutside,:));
    XYZbeadsPBC{i}(ioutside(any(divsoutend

XYZbeadsPBCall = cat(1,XYZbeadsPBC{:});
XYZbeadsPBCidall = cat(1,XYZbeadsPBCid{:});
isPBCallok = ~isnan(XYZbeadsPBCall(:,1));
XYZbeadsPBCall = XYZbeadsPBCall(isPBCallok,:);
XYZbeadsPBCidall = XYZbeadsPBCidall(isPBCallok,:);

% control while keeping the generational index (saved in R1)
R1(1).XYZbeadsPBCall = XYZbeadsPBCall;
R1(1).XYZbeadsPBCidall = XYZbeadsPBCidall;
if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R1) **********
    hfig = fighandle('packing');  hold on
    colors = tooclear(hsv(R1(1).ngenerations)); %turbo
    for igen=1:R1(1).ngenerations
        viscircles(R1(1).XYZbeadsPBCall(R1(1).XYZbeadsPBCidall==igen,:),R1(1).rLagrangian,'color',colors(igen,:));
    end
    title(sprintf('t=%0.3f s - one color per injection line',tframe)), axis equal
    if PRINTON, printhandle(hfig), end
end

%% Filtering: remove overlapping from different injections using a first estimate of density
dispsection('CLEAN BEAD DENSITY')
% Summary
% This methodology effectively redistributes beads to ensure that local densities do not exceed
% the physical limits of the simulation, enhancing realism and accuracy. By adjusting bead 
% distributions based on calculated densities and employing PBC to handle edge cases, the script 
% ensures a uniformly plausible representation of bead distributions across the simulation domain.

hfilter = 4*rLagrangian;
XYbeadsfilterid = XYZbeadsPBCidall;
XYbeadsfilter = XYZbeadsPBCall; 
nfilter = size(XYbeadsfilter,1);
XYbeadsfilter_images= PBCimages(XYbeadsfilter,box(1:2,:),[true,true],2*hfilter);
XYbeadsfilterwithImages = [XYbeadsfilter;XYbeadsfilter_images];
Vbeadsfilter = buildVerletList(XYbeadsfilter,hfilter);
VbeadsfilterBC = buildVerletList({XYbeadsfilter XYbeadsfilterwithImages},hfilter);
Volfilter = length(find(~isnan(rhobeadXYZgrid(:))))/numel(rhobeadXYZgrid) * boxsize(1) * boxsize(2) * s;
mfilter = rho*Volfilter/size(XYbeadsfilter,1); % mass of a single bead (informed)
Vfilter = mfilter/rho;
Wfilter = kernelSPH(hfilter,'lucy',2);
rhofilter = interp2SPHVerlet(...
    XYbeadsfilterwithImages,...
    rho*ones(size(XYbeadsfilterwithImages,1),1),...
    XYbeadsfilter,VbeadsfilterBC,Wfilter,Vfilter)/s; 

% target
rhomax = 1500;
ok = rhofilter<=rhomax;

% before (saved in R1)
R1(1).XYbeadsfilter = XYbeadsfilter;
R1(1).ok = ok;
if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R1) **********
    hfig = fighandle('packing_rhomax');  hold on
    viscircles(R1(1).XYbeadsfilter(R1(1).ok,:),R1(1).rLagrangian,'color','b');
    viscircles(R1(1).XYbeadsfilter(~R1(1).ok,:),R1(1).rLagrangian,'color','r');
    title(sprintf('t=%0.3f s - in red: excess density',tframe)), axis equal
    if PRINTON, printhandle(hfig), end
end

% do filter
itoohigh = find(~ok);
[rhotoohigh,ind] = sort(rhofilter(itoohigh),'descend');
itoohigh = itoohigh(ind);
kept = true(nfilter,1);
for k=1:length(itoohigh)
    % valid neighbors (only)
    jBC = VbeadsfilterBC{itoohigh(k)}; % it includes self with images
    njBC = length(jBC);
    j = Vbeadsfilter{itoohigh(k)}; % it includes self without images
    j = j(kept(j));
    [idj,ind] = sort(XYbeadsfilterid(j),'ascend');
    j = j(ind);  nj = length(j);
    jdeletable = j(find(idj>min(idj),1,'first'):end); % we keep the first type
    [rhojdeletable,ind] = sort(rhofilter(jdeletable),'descend');
    jdeletable = jdeletable(ind); njdeletable = length(jdeletable);
    njexcess = floor( (1 - rhomax/rhotoohigh(k)) * njBC );
    kept(jdeletable(1:min(njexcess,njdeletable))) = false;
end

% after  (saved in R1)
R1(1).kept = kept;
if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R1) **********
    hfig = fighandle('packing_rhomax_fix');  hold on
    viscircles(R1(1).XYbeadsfilter(R1(1).kept,:),R1(1).rLagrangian,'color','g');
    viscircles(R1(1).XYbeadsfilter(~R1(1).kept,:),R1(1).rLagrangian,'color','r');
    title(sprintf('t=%0.3f s - in red: removed beads',tframe)), axis equal
    if PRINTON, printhandle(hfig), end
end


%% calculate density
dispsection('INFORMED DENSITY')
XYinformed = PBCincell(XYZbeadsPBCall(kept,:),box,[true true]); % PBC just to be sure
ninformed = size(XYinformed,1);
rinformed = rLagrangian; %radius
sinformed = 2*rinformed; % separation distance
hinformed = 5*sinformed; % for integration

% add PBC images
[XYinformed_images ,indimages]= PBCimages(XYinformed,box(1:2,:),[true,true],2*hinformed);
XYinformedwithImages = [XYinformed;XYinformed_images];
% Verlet list for the original grid
XYgrid = [Xw(:) Yw(:)];
if isprefetch('VXYinformed')
    load(prefetchvar('VXYinformed'))
else
    VXYinformed  = buildVerletList({XYgrid XYinformedwithImages},hinformed);
    save(prefetchvar('VXYinformed'),'VXYinformed')
end
% Verlet list for the informed beads
if isprefetch('VXYbeadinformed')
    load(prefetchvar('VXYbeadinformed'))
else
    VXYbeadinformed = buildVerletList({XYinformed XYinformedwithImages},hinformed);
    save(prefetchvar('VXYbeadinformed'),'VXYbeadinformed')
end
   

% Calculate the mass of informed beads
% total volume of fluid in the image
Volinformed = length(find(~isnan(rhobeadXYZgrid(:))))/numel(rhobeadXYZgrid) * boxsize(1) * boxsize(2) * s;
mbeadinformed = rho*Volinformed/ninformed; % mass of a single bead (informed)

% 2D Kernel
Winformed = kernelSPH(hinformed,'lucy',2); % kernel expression [/m2]

% Calculate the volume of the beads
Vbeadinformedguess = mbeadinformed/rho; % first guess
% density at the centers of the informed beads
rhobeadinformed = interp2SPHVerlet(XYinformedwithImages,rho*ones(size(XYinformedwithImages,1),1),XYinformed,VXYbeadinformed,Winformed,Vbeadinformedguess);
rhobeadinformed = rhobeadinformed/s; % the thickness is not known, s is used instead of sinformed for consistency
rhobeadinformedwithImages = [rhobeadinformed;rhobeadinformed(indimages)];
% rhobeadinformed(rhobeadinformed<200) = NaN;
% rhobeadinformed(isnan(rhobeadinformed)) = median(rhobeadinformed,'omitmissing'); 

% volume of the informed beads
Vbeadinformed = mbeadinformed./rhobeadinformed;
% normalized radius of informed beads
rbeadinformed = sqrt(Vbeadinformed/(s*pi));
rbeadinformed = rbeadinformed/median(rbeadinformed,'omitmissing') * rLagrangian;

% control figure  (saved in R1)
R1(1).rinformed = rinformed;
R1(1).sinformed = sinformed;
R1(1).hinformed = hinformed;
R1(1).XYinformed = XYinformed;
R1(1).rhobeadinformed = rhobeadinformed;
R1(1).rbeadinformed = rbeadinformed;
if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R1) **********
    figure, viscircles(R1(1).XYinformed,R1(1).rLagrangian,'color','g'); axis equal, hold on
    viscircles(R1(1).XYinformed,R1(1).rbeadinformed,'color','r');
end

% reference density at the same positions (saved in R0)
XYZeqinformed = [XYinformed ones(ninformed,1)*ztop];
VXYZeqinformed  = buildVerletList({XYZeqinformed XYZwithImages},1.2*h);
rhobeadXYZ2XYinformed = interp3SPHVerlet(XYZwithImages,rhobeadXYZwithImages,XYZeqinformed,VXYZeqinformed,W,VbeadXYZwithImages);
R0(1).XYZeqinformed = XYZeqinformed;
R0(1).rhobeadXYZ2XYinformed = rhobeadXYZ2XYinformed;

% density on the grid (saved in R1)
if isprefetch('dgrid')
    load(prefetchvar('dgrid'))
else
    % note that rho and Vbeadinformedguess should have the same origin so that rho*Vbeadinformedguess equals mbeadinformed
    dgrid = interp2SPHVerlet(XYinformedwithImages,rho*ones(size(XYinformedwithImages,1),1),XYgrid,VXYinformed,Winformed,Vbeadinformedguess);
    save(prefetchvar('dgrid'),'dgrid')
end
dgrid = reshape(dgrid/s,size(Xw)); % /s to get in kg/m3 from kg/m2
dgrid(isnan(rhobeadXYZgrid)) = NaN; % we mask the objects (pillar and sphere) the same way as in the reference
R1(1).dgrid = dgrid;

%% Evaluate Landshoff forces - added 29,30/03/2024
dispsection('LANDSHOFF')
% reference velocity
XYZinformed = [XYinformed ones(size(XYinformed,1),1)*ztop];
VXYZ_forinformed = buildVerletList({XYZinformed XYZwithImages},1.2*hinformed);
if isprefetch('Velocity_beadinformed')
    load(prefetchvar('Velocity_beadinformed'))
else
    Velocity_beadinformed = interp3SPHVerlet(XYZwithImages,vXYZwithImages,XYZinformed,VXYZ_forinformed,W,VbeadXYZwithImages);
    save(prefetchvar('Velocity_beadinformed'),'Velocity_beadinformed')
end
Velocity_beadinformed_withimages = [Velocity_beadinformed;Velocity_beadinformed(indimages,:)];

% configuration for Landshoff
% Since the scaling is not clear in 2D, q1 is left to one

% maxVelocity = max(vXYZ,[],'all');
% MachTarget = 0.1;
c0 = 1500; % maxVelocity / MachTarget;
dynamicViscosity = 0.13; % Pa.s
q1 = 1; % 8 * dynamicViscosity / (hinformed*c0*rho);
config  = struct( ...real dynamic viscosity: rho * q1 * h * c0 / 8 (2D) or 10 (3D)
   'gradkernel', kernelSPH(hinformed,'lucyder',2),...% kernel gradient (note that h is bound with the kernel)
            'h', hinformed,...smoothing length
           'c0',c0,...        speed of the sound
           'q1',q1,...         constant
          'rho', rhobeadinformedwithImages, ...    fluid density
         'mass', mbeadinformed,...        bead weight
          'vol', sinformed * mbeadinformed./rhobeadinformedwithImages, ...       bead volume (uniquely for virial stress)
'repulsiononly', false ...    if true, only Landshoff forces when dot(rij,vij)<0
    );

% Landshoff forces
VXYZ_forinformedwithImages = buildVerletList(XYinformedwithImages,1.2*hinformed);
[FXY_tmp,WXY_tmp] = forceLandshoff(...
    XYinformedwithImages,...
    Velocity_beadinformed_withimages(:,1:2),...
    VXYZ_forinformedwithImages,...
    config);
FXY_beadsinformedwithImages = [FXY_tmp(1:size(XYinformed,1),:); FXY_tmp(indimages,:)];
WXY_beadsinformedwithImages = [WXY_tmp(1:size(XYinformed,1),:); WXY_tmp(indimages,:)];
if isprefetch('FXYgrid')
    load(prefetchvar('FXYgrid'))
else
    FXYgrid = interp2SPHVerlet(XYinformedwithImages,FXY_beadsinformedwithImages,XYgrid,VXYinformed,Winformed,Vbeadinformedguess);
    save(prefetchvar('FXYgrid'),'FXYgrid')
end
if isprefetch('WXYgrid')
    load(prefetchvar('WXYgrid'))
else
    WXYgrid = interp2SPHVerlet(XYinformedwithImages,WXY_beadsinformedwithImages,XYgrid,VXYinformed,Winformed,Vbeadinformedguess);
    save(prefetchvar('WXYgrid'),'WXYgrid')
end
F1XYgrid = reshape(FXYgrid(:,1),size(Xw));
F2XYgrid = reshape(FXYgrid(:,2),size(Xw));
W11XYgrid = reshape(WXYgrid(:,1),size(Xw)); 
W22XYgrid = reshape(WXYgrid(:,4),size(Xw));
W12XYgrid = reshape(WXYgrid(:,2),size(Xw));
W21XYgrid = reshape(WXYgrid(:,3),size(Xw));
F1XYgrid(isnan(rhobeadXYZgrid)) = NaN;
F2XYgrid(isnan(rhobeadXYZgrid)) = NaN;
W11XYgrid(isnan(rhobeadXYZgrid)) = NaN;
W22XYgrid(isnan(rhobeadXYZgrid)) = NaN;
W12XYgrid(isnan(rhobeadXYZgrid)) = NaN;

% save results in R1
R1(1).xw = xw;
R1(1).yw = yw;
R1(1).Xw = Xw;
R1(1).Yw = Yw;
R1(1).F1XYgrid = F1XYgrid;
R1(1).F2XYgrid = F2XYgrid;
R1(1).W11XYgrid = W11XYgrid;
R1(1).W22XYgrid = W22XYgrid;
R1(1).W12XYgrid = W12XYgrid;
R1(1).W21XYgrid = W21XYgrid;

if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R1) **********
    % distribution of Landshoff forces (not meaningful on a grid) - just for control
    figure,  hold on
    hp = pcolor(R1(1).xw,R1(1).yw,abs(R1(1).W12XYgrid)); hp.EdgeColor = 'none'; colorbar
    step = 25;
    quiver(R1(1).Xw(1:step:end,1:step:end),R1(1).Yw(1:step:end,1:step:end),...
        R1(1).F1XYgrid(1:step:end,1:step:end),R1(1).F2XYgrid(1:step:end,1:step:end),2,'color','k','LineWidth',0.5)
    title(sprintf('[t=%0.3g s] informed shear stress (kg/m3)',tframe)), axis equal %, clim([500 1300])
    % distribution of Landshoff stresses
    hfig = fighandle('Landshoff_stress');  hold on
    hp = pcolor(R1(1).xw,R1(1).yw,abs(R1(1).W12XYgrid)); hp.EdgeColor = 'none'; colorbar
    step = 25;
    quiver(R1(1).Xw(1:step:end,1:step:end),R1(1).Yw(1:step:end,1:step:end),...
        R1(1).W11XYgrid(1:step:end,1:step:end),R1(1).W22XYgrid(1:step:end,1:step:end),2,'color','k','LineWidth',0.5)
    title(sprintf('[t=%0.3g s] Landshoff - shear (abs(Lxy)) - Lxx,Lyy (Pa)',tframe)), axis equal %, clim([500 1300])
end

% gradient of velocity (saved in R1)
[gxx,gxy] = gradient(vxXYZgrid,Xw(1,2)-Xw(1,1));
[gyx,gyy] = gradient(vyXYZgrid,Yw(2,1)-Yw(1,1));
R1(1).gxx = gxx;
R1(1).gxy = gxy;
R1(1).gyx = gyx;
R1(1).gyy = gyy;

if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R1) **********
    figure, hold on, title('Gradient of velocity: xx, yy and xy')
    hp = pcolor(R1(1).xw,R1(1).yw,abs(R1(1).gxy+R1(1).gyx)/2); hp.EdgeColor = 'none'; colorbar
    step = 25;
    quiver(R1(1).Xw(1:step:end,1:step:end),R1(1).Yw(1:step:end,1:step:end),...
        R1(1).gxx(1:step:end,1:step:end),R1(1).gyy(1:step:end,1:step:end),2,'color','k','LineWidth',0.5)
end

% Viscosity control (saved in R1)
r = abs(W12XYgrid./gxy); r(isinf(r)) = NaN;
dynamicViscosity_estimated = r/(sinformed*rho);
R1(1).r = r;
R1(1).dynamicViscosity = dynamicViscosity;
R1(1).dynamicViscosity_estimated = dynamicViscosity_estimated;

if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R1) **********
    % map
    hfig(end+1) = fighandle('Viscosity_estimate');  hold on
    imagesc(log10(R1(1).dynamicViscosity_estimated/R1(1).dynamicViscosity)), colorbar, clim([-2 2])
    title(sprintf('[t=%0.3g s] Estimated/Real Viscosity (log)',tframe)), axis equal
    % distribution
    hfig(end+1) = fighandle('Viscosity_estimate_dist');  hold on
    histogram(log10(R1(1).dynamicViscosity_estimated/R1(1).dynamicViscosity))
    title(sprintf('[t=%0.3g s] Estimated/Real Viscosity (log)',tframe))
end

% print
if PRINTON && PLOTON
    for i=1:length(hfig)
        figure(hfig(i)), drawnow
        printhandle(hfig(i))
    end
end

%% ---------------------------- PRODUCTION FIGURES
if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R1 and R0) **********
    hfig = []; close all

    % Density mapped on beads
    hfig(end+1) = fighandle('d_bead_informed'); hold on, title(sprintf('[t=%0.3g s] density mapped to informed beads',tframe))
    scatter(R1(1).XYinformed(:,1),R1(1).XYinformed(:,2),100*(R1(1).rbeadinformed/min(R1(1).rbeadinformed)).^2,R1(1).rhobeadinformed,'filled'), colorbar
    hfig(end+1) = fighandle('d_bead_reference'); hold on, title(sprintf('[t=%0.3g s] reference density mapped to informed beads',tframe))
    scatter(R0(1).XYZeqinformed(:,1),R0(1).XYZeqinformed(:,2),100*(R1(1).rbeadinformed/min(R1(1).rbeadinformed)).^2,R1(1).rhobeadXYZ2XYinformed,'filled'), colorbar
    hfig(end+1) = fighandle('d_bead_informed_vs_reference'); plot(R0(1).rhobeadXYZ2XYinformed(:),R1(1).rhobeadinformed(:),'ro'), xlabel('reference density (back mapped)'), ylabel('informed density')
    title(sprintf('[t=%0.3g s] informed vs. reference density',tframe))

    % density mapped on the grid
    hfig(end+1) = fighandle('d_grid_informed'); hp = pcolor(R1(1).xw,R1(1).yw,R1(1).dgrid); hp.EdgeColor = 'none'; colorbar, title(sprintf('[t=%0.3g s] informed density (kg/m3)',tframe)), axis equal %, clim([500 1300])
    haxtomodify = gca;
    hfig(end+1) = fighandle('d_grid_reference'); hp = pcolor(R1(1).xw,R1(1).yw,R0(1).rhobeadXYZgrid); hp.EdgeColor = 'none'; colorbar, title(sprintf('[t=%0.3g s] reference density (kg/m3)',tframe)), axis equal %, clim([500 1300])
    clim(haxtomodify,clim)

    % distribution of densities
    hfig(end+1) = fighandle('distribution_rho');  hold on
    histogram(R1(1).rhobeadinformed), histogram(R0(1).rhobeadXYZ2XYinformed), legend({'informed density','reference density'})
    title(sprintf('[t=%0.3g s] Density distributions',tframe))
end

%% -- identify the beads in contact with objects based on density
% SUMMARY.
% This section outlines a methodology for identifying beads in contact with solid objects
% in a fluid simulation, particularly focusing on density-based criteria to determine close
% interactions and potential contact forces.
dispsection('OBJECT DETECTION')
% Attention the sphere can exceed the area observed (overflow condition)
% Safe coordinates are only use for contour identification
isynan = isnan(mean(rhobeadXYZgrid(:,floor(size(rhobeadXYZgrid,2)*0.6):end),2));
isoverflow =  (find(isynan,1,'last')-find(isynan,1,'first')+1)==size(rhobeadXYZgrid,1);
if (find(isynan,1,'last')-find(isynan,1,'first')+1)==size(rhobeadXYZgrid,1) % reach top
    iyoverflow = find(~isynan,1,'first');
    iymargin = round(size(rhobeadXYZgrid,1)*0.1); % margin to add
    iysafe = iyoverflow+iymargin;          % index translation (along y)
    dysafe = -iysafe * ( Yw(2,1)-Yw(1,1) ); % distance translation (along y)
    [rXYgridsafe,Xwsafe,Ywsafe] = PBCgridshift(Xw,Yw,rhobeadXYZgrid,[0 iysafe]); % translate
    dgridsafe = PBCgridshift(Xw,Yw,dgrid,[0 iysafe]); % translate
    [XYinformedsafe,boxsafe] = PBCimagesshift(XYinformed,[0 dysafe],box(1:2,1:2));
elseif find(isynan,1,'first')==1
    iymargin = round(size(rhobeadXYZgrid,1)*0.1); % margin to add
    iyoverflow = iymargin;
    if isynan(end), iyoverflow = iyoverflow + length(iyoverflow)-find(~isynan,1,'last'); end
    iysafe = -iyoverflow;
    dysafe = -iysafe * ( Yw(2,1)-Yw(1,1) ); % distance translation (along y)
    [rXYgridsafe,Xwsafe,Ywsafe] = PBCgridshift(Xw,Yw,rhobeadXYZgrid,[0 iysafe]); % translate
    dgridsafe = PBCgridshift(Xw,Yw,dgrid,[0 iysafe]); % translate
    [XYinformedsafe,boxsafe] = PBCimagesshift(XYinformed,[0 dysafe],box(1:2,1:2));
else
    dysafe = 0;
    [rXYgridsafe,Xwsafe,Ywsafe] = deal(rhobeadXYZgrid,Xw,Yw);
    [dgridsafe,XYinformedsafe,boxsafe] = deal(dgrid,XYinformed,box);
end

% Volume of objects (GRID points): XYobjects where density is NaN vy definition
XYobjects = [Xwsafe(:) Ywsafe(:)];
XYobjects = XYobjects(isnan(rXYgridsafe),:);
% Looking for beads in contact with XYobjects (grid points)
V2 = buildVerletList({XYinformedsafe XYobjects},3*sinformed);
% Index of beads in contact with XYobjects (grid points)
icontact = find(cellfun(@length,V2)>0);
XYcontact = double(XYinformedsafe(icontact,:));
% Enclosed beads
k = boundary(XYcontact,1); nk = length(k);
XYcontactk = XYcontact(k,:);

% separation of the objects, contour parameterization, tangents, normals
% the pillar is assumed fixed
pillarcenter = [2.87,3.08]*1e-4; % 0.2880e-3    0.3131e-3, mean(objects(1).XY)
ispillar = vecnorm(XYcontactk - pillarcenter,2,2)<0.8e-4; %  7.7859e-05, max(vecnorm(XYcontactk(ispillar,:) - pillarcenters,2,2))
objects = struct('name',{'pillar','sphere'},'XY',{XYcontactk(ispillar,:) XYcontactk(~ispillar,:)},'marker',{'bo','ms'},'line',{'b-','m-'},'color',{'b','m'});
anglestep = pi/32;
angles = (-pi:anglestep:pi)';
for k = 1:length(objects)
    % fit each object as a circle to try to close the boundaries
    objects(k).fit = fitCircleFromPoints(objects(k).XY);
    missingangles = angles(abs(angles-objects(k).fit.angles(nearestpoint(angles,objects(k).fit.angles)))>anglestep);
    XYtoadd = objects(k).fit.XYgenerator(missingangles);
    XYclosed = [objects(k).XY;XYtoadd]; nXYclosed = floor(size(XYclosed,1)/2)*2;
    [anglesclosed,ind] = sort(objects(k).fit.angleGenerator(XYclosed));
    XYclosed = XYclosed (ind,:); % sort points according to angles
    % enforce periodic conditions along the index dimension
    objects(k).XYclosed = [XYclosed((nXYclosed/2+1):end,:) ; XYclosed ; XYclosed(1:(nXYclosed/2),:)];
    objects(k).n = size(objects(k).XYclosed,1);

    % First pass - contour twice longer than the real one
    % fit each obhect using a regularized spline approximation
    sp = csaps((1:objects(k).n)',objects(k).XYclosed',0.25); % smoothed cubic spline
    %sp = spaps((1:objects(k).n)',objects(k).XYclosed',0.001*sum(var(objects(k).XYclosed))*objects(k).n);
    spder = fnder(sp,1);

    % Second pass - approximation based on angles
    xycontours = fnval(sp,sp.breaks)';
    dxycontours = fnval(spder,sp.breaks)';
    xycircle = fitCircleFromPoints(xycontours);
    [xyangles,ind] = sort(xycircle.angles,'ascend');
    minangle = min(xyangles);
    maxangle = max(xyangles);
    xyangles = (2*(xyangles-minangle)/(maxangle-minangle)-1) * pi; % rescaled to close the figure
    xycontoursf = [ smooth(xyangles,xycontours(ind,1),0.15,'rloess'),...
                    smooth(xyangles,xycontours(ind,2),0.15,'rloess') ];
    dxycontoursf = [ smooth(xyangles,dxycontours(ind,1),0.15,'rloess'),...
                    smooth(xyangles,dxycontours(ind,2),0.15,'rloess') ];

    % Make all data unique
    [xyangles,ind] = unique(xyangles,'stable');
    xycontoursf = xycontoursf(ind,:);
    dxycontoursf = dxycontoursf(ind,:);
    xycontoursf([1 end],:) = [1;1] * mean(xycontoursf([1 end],:));
    dxycontoursf([1 end],:) = [1;1] * mean(dxycontoursf([1 end],:));

    % Third Pass using contour length instead of angle as variable
    % ATTENTION: for averaging it is preferable to use curvilinear coordinates
    lxycontour = [0; cumsum(sqrt(sum(diff(xycontoursf,1,1).^2,2)))];
    sp2 = csaps(lxycontour',xycontoursf');


    % Extract tangents at prescribed curvilinear coordinates
    xp = linspace(lxycontour(1),lxycontour(end),objects(k).n)';
    % center and apparent radius (for visualizing the force acting on the object)
    objects(k).XYboundary = fnval(sp2,xp)';
    objects(k).center = mean(objects(k).XYboundary);
    objects(k).radius = min(vecnorm(objects(k).XYboundary-objects(k).center,2,2));
    % tangents (from the spline approximation)
    %objects(k).tangents = ndf(xp,objects(k).XYboundary,1,[],'makeuniform',true); %curve2tangent(objects(k).XYboundary); %fnval(fnder(sp2,1),xp)';
    objects(k).tangents = fnval(fnder(sp2,1),xp)';
    objects(k).tangents = objects(k).tangents./vecnorm(objects(k).tangents,2,2); % Normalize the tangent vectors
    % normals (turn the normals to be inwards using inpolygon)
    objects(k).normals = [-objects(k).tangents(:,2),objects(k).tangents(:,1)]; % % Calculate the centroid of the shape
    testPoints = objects(k).XYboundary + 0.01 * objects(k).radius * objects(k).normals; % Choose a test point slightly offset from each boundary point along the normal
    isInside = inpolygon(testPoints(:,1), testPoints(:,2),...
        objects(k).XYboundary(:,1), objects(k).XYboundary(:,2)); % Use inpolygon to check if each test point is inside the shape
    objects(k).normals(~isInside, :) = -objects(k).normals(~isInside, :); % Flip the normals where the test point is outside the shape
    % add density, pressure information (look for the nearest beads closest to the boundary, average the value)
    objects(k).Vcontact = buildVerletList({objects(k).XYboundary XYcontact},3*sinformed);
    objects(k).Vcontact = cellfun(@(v) icontact(v)',objects(k).Vcontact,'UniformOutput',false); % Vcontact{i} index of beads in contact with XYboundary(i,:)
    objects(k).rhocontact = cellfun(@(v) mean(rhobeadinformed(v)),objects(k).Vcontact);
    objects(k).Pcontact = 1 + (objects(k).rhocontact/rho).^7-1; % reduced pressure P/B with P0/B=1
    objects(k).densitynormals = objects(k).rhocontact.*objects(k).normals/rho;
    objects(k).avdensitynormals = mean(objects(k).densitynormals,'omitmissing');
    objects(k).pressurenormals = objects(k).Pcontact.*objects(k).normals;
    objects(k).avpressurenormals = mean(objects(k).pressurenormals,'omitmissing');
end

% save results in R1
R1(1).XYcontact = XYcontact;
R1(1).objects = {objects.name};
for k=1:length(objects)
    R1(1).(objects(k).name) = objects(k);
end
R1(1).Xwsafe = Xwsafe;
R1(1).Ywsafe = Ywsafe;
R1(1).dgridsafe = dgridsafe;

% plot
if PLOTON % <<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-<<-(saved in R1) **********
    hfig(end+1) = fighandle('distribution_forces');  hold on
    set(hfig(end),'PaperPosition',[ -2.0000    1.7000   30.0000   30.0000])
    step = 2;
    hp = pcolor(Xwsafe(1,:),Ywsafe(:,1),dgridsafe); hp.EdgeColor = 'none'; colorbar
    quiv = struct('xy',[],'nxy',[],'mag',[],'nscale',2);
    for k = 1:length(R1(1).objects)
        currentobject = R1(1).objects{k};
        % viscircles(R1(1).XYcontact,R1(1).rinformed,'color','r');
        % plot(R1(1).(currentobject).XY(:,1),R1(1).(currentobject).XY(:,2),R1(1).(currentobject).marker)
        plot(R1(1).(currentobject).XYboundary(:,1),R1(1).(currentobject).XYboundary(:,2),R1(1).(currentobject).line,'linewidth',2,'marker','x')
        quiv.xy  = [quiv.xy;  R1(1).(currentobject).XYboundary(1:step:end,:);  R1(1).(currentobject).center];
        quiv.nxy = [quiv.nxy; R1(1).(currentobject).pressurenormals(1:step:end,:); quiv.nscale*R1(1).(currentobject).avpressurenormals];
        quiv.mag = [quiv.mag; R1(1).(currentobject).Pcontact(1:step:end);mean(R1(1).(currentobject).Pcontact,'omitmissing')];
    end
    % all quivers at once (color
    hq = quiver(quiv.xy(:,1),quiv.xy(:,2),quiv.nxy(:,1),quiv.nxy(:,2),3,'color','k','LineWidth',0.5);
    SetQuiverColor(hq,tooclear(jet),'mags',quiv.mag,'range',[0 0.5])
    axis equal, title(sprintf('[t=%0.3g s] Pressure around objects',tframe))
end



%% print
if PRINTON && PLOTON
    for i=1:length(hfig)
        figure(hfig(i)), drawnow
        printhandle(hfig(i))
    end
end
% save
if ~exist(savefile(),'file') || OVERWRITE
    save(savefile(),'R0','R1')
    dispf('\n-->Results for tframe=%0.4g s have been saved',tframe)
    fileinfo(savefile())
end

dispsection('100% complete')


% relative pressure via Tait equation
% Pref = (rhobeadXYZgrid./rho).^7 - 1; % reference pressure
% Pbead = (rhobeadinformed./rho).^7 - 1; % pressure at kernel positions
% Pgrid = (dgrid./rho).^7 - 1; % pressure at grid nodes
% Pgrid = min(Pref(:)) + (max(Pref(:))-min(Pref(:)))*(Pgrid-min(Pgrid(:)))/(max(Pgrid(:))-min(Pgrid(:)));
% figure, imagesc(xw,yw,Pgrid), colorbar, title('dimensionless pressure (-)'), axis equal
% clim([-1 3]), colorbar
% figure, imagesc(xw,yw,Pref), colorbar, title('reference dimensionless pressure (-)'), axis equal
% clim([-1 3]), colorbar
% figure, scatter(XYinformed(:,1),XYinformed(:,2),rbeadinformed,Pbead,'filled')

% ####################################################################################
%   This is fork of the main script Billy_reusults_template_PBC
%   To be used for testing alternative parameters on a non main stream machine
% ####################################################################################

% First template to retrieve Billy's paper 2 simulation data 
% rev. 2024/03/17 - forked in 2024/03/16 with PBC

% 2024/03/07 implementation of reverse streamlines, streamline binning from their initial positions, subsampling
% 2024/03/12 implement bead along streamlines (bug:NaN and Inf not allowed.) 
% 2024/03/16 fork from Billy_results_template.m (MAJOR UPDATE)
% 2024/03/17 release candidate
% 2024/03/21 preproduction
% 2024/03/24 major update: full implementation of density correction and force contours around objects
% 2024/03/24 selective copy possible if originalroot is made available
% 2024/03/24 add prefetch management
% 2024/03/25 first batch of preproduction tframe 0.3->1.1 (step 0.01)
% 2024/03/26 second batch of preproduction tframe 0.11->0.4 (step 0.01)
% 2024/03/27 fix streamlines when less than one bead must be added (tframe = 0.11 and 0.27)
% 2024/03/27 fix contour, tangents/normals, add perssure
% 2024/03/27 Senstivity challenge test using ngenerations = 8 and xshift = double(mod(igen-1,2)*(xwPBC(indxstreamline(2))-xwPBC(indxstreamline(1))));


% SUMMARY

% This MATLAB script is a comprehensive framework for analyzing fluid dynamics simulations, specifically focusing on the distribution and movement of particles or beads in a fluid environment. Key functionalities include:
% 
% 1. Environment Setup:
%   Initializes the simulation environment by clearing variables, setting up output folders, and defining file paths to simulation data, with adjustments for periodic boundary conditions (PBC).
% 2. Data Retrieval:
%   Loads simulation data from specified file paths, handling different configurations and viscosity models.
% 3. Simulation Analysis:
%   Processes the simulation data to calculate parameters such as bead sizes, timestep intervals, and spatial distributions of particles.
% 4. Frame Selection:
%   Identifies simulation frames for detailed analysis based on time criteria, with capabilities to adjust for available data subsets.
% 5. Velocity Field and Density Calculation:
%   Computes the velocity field at a specific plane in the simulation domain and estimates the local density of particles.
% 6. Streamline and Bead Distribution Analysis:
%   Generates streamlines and distributes beads along these lines, incorporating PBC adjustments to simulate continuous fluid flow across boundaries.
% 7. Overlap Removal:
%   Implements algorithms to remove overlapping beads based on their spatial proximity and streamline generation, ensuring a realistic particle distribution.
% 8. Density Filtering:
%   Filters out beads in regions of excessively high simulated density to adhere to physical constraints.
% 9. Contact Detection with Objects:
%   Identifies beads in contact with solid objects within the simulation, leveraging density information to infer interaction dynamics.
% 10. Visual Representation:
%   Provides extensive plotting capabilities to visualize various aspects of the simulation, including velocity fields, bead distributions, and pressure around objects, with options to export figures.

%% Definitions
close all
clearvars -except tframe tframelist RESETPREFETCH
outputfolder = fullfile(pwd,'preproduction');
prefetchfolder = fullfile(pwd,'prefetch');
if ~exist(outputfolder,'dir'), mkdir(outputfolder); end
if ~exist(prefetchfolder,'dir'), mkdir(prefetchfolder); end
fighandle = @(id) formatfig(figure,'figname',sprintf('t%0.3g_%s',tframe,id));
printhandle = @(hfig) print_png(300,fullfile(outputfolder,[get(hfig,'filename') '.png']),'','',0,0,0);
if ~exist('RESETPREFETCH','var'), RESETPREFETCH = false; end
prefetchvar = @(varargin) fullfile(prefetchfolder,sprintf('t%0.4f_%s.mat',tframe,varargin{1}));
isprefetch = @(varargin) exist(prefetchvar(varargin{1}),'file') && ~RESETPREFETCH;

%% path and metadata
originalroot = '/media/olivi/T7 Shield/Thomazo_V2';
if exist(originalroot,'dir')
    root = originalroot;
    rootlocal = fullfile(pwd,'smalldumps');
    copymode = true;
else
    root = fullfile(pwd,'smalldumps');
    copymode = false;
end

simfolder = ...
    struct(...
    'A1',struct('artificial',...
'Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz',...
    'Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz' ...
                ),...
    'A2',struct('artificial',...
'./Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_2.tar.gz' ...
    ),...
    'B1',struct('Morris',...
'./Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft.tar.gz' ...
    ),...
    'B2',struct('Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_1.tar.gz' ...
    ),...
    'B3',struct('Morris',...
'/Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_2_3.tar.gz' ...
    ) ...
    );

% selection (not change it if you do not have the full dataset/hard disk attached to your system)
config = 'A1';
viscosity = 'Morris';
sourcefolder= fullfile(root,rootdir(simfolder.(config).(viscosity)));
sourcefile = regexprep(lastdir(simfolder.(config).(viscosity)),'.tar.gz$','');
dumpfile = fullfile(sourcefolder,sourcefile);

%% extract information
X0 = lamdumpread2(dumpfile); % first frame
natoms = X0.NUMBER;
timesteps = X0.TIMESTEPS;
X1 = lamdumpread2(dumpfile,'usesplit',[],timesteps(2));
dt = (X1.TIME-X0.TIME)/(timesteps(2)-timesteps(1)); % integration time step
times = double(timesteps * dt); % in seconds 
atomtypes = unique(X0.ATOMS.type);
ntimesteps = length(timesteps);
T = X0.ATOMS.type;
natomspertype = arrayfun(@(t) length(find(T==t)),atomtypes);
[~,ind] = sort(natomspertype,'descend');
% Thomazo simulation details
fluidtype  = ind(1);
pillartype = ind(2);
walltype   = ind(3);
spheretype = ind(4);
coords = {'z','x','y'}; % to match Thomazo's movies
vcoords = cellfun(@(c) sprintf('v%s',c),coords,'UniformOutput',false);
icoords = cellfun(@(c) find(ismember({'x','y','z'},c)),coords); %<- use this index for BOX
% Simulation parameters
mbead = 4.38e-12; % kg
rho = 1000; % kg / m3 (density of the fluid)
Vbead = mbead/rho;


%% copy files (if possible)
if copymode
    myprefetchfile = @(itime) sprintf('%s%09d.mat','TIMESTEP_',itime);
    myprefetchfolder = @(d) fullfile(d,sprintf('PREFETCH_%s',lastdir(dumpfile)));
    destinationfolder = fullfile(rootlocal,rootdir(simfolder.(config).(viscosity)));
    sourcefolderPREFETCH = myprefetchfolder(sourcefolder);
    destinationfolderPREFETCH = myprefetchfolder(destinationfolder);
    tcopy = 0.1:0.01:1.1;
    tfile = arrayfun(@(t) myprefetchfile(t), timesteps(unique(nearestpoint(tcopy,times))),'UniformOutput',false);
    oksource = all(cellfun(@(f) exist(fullfile(sourcefolderPREFETCH,f),'file'),tfile));
    if ~oksource, error('the source folder is corrupted, please check'), end
    existingfiles = cellfun(@(f) exist(fullfile(destinationfolderPREFETCH,f),'file'),tfile);
    dispf('Number of files to copy: %d (%d already available)',length(find(~existingfiles)),length(find(existingfiles)))
    copysuccess = cellfun(@(f) copyfile(fullfile(sourcefolderPREFETCH,f),fullfile(destinationfolderPREFETCH,f)),tfile(~existingfiles));
    dispf('%d of %d files have been copied',length(find(copysuccess)),length(copysuccess));
end

%% Estimate bead size from the first frame
% first estimate assuming that the bead is a cube
fluidxyz0 = X0.ATOMS{T==fluidtype,coords};
boxdims = X0.BOX(:,2) - X0.BOX(:,1);
Vbead_guess = prod(boxdims)/natoms;
rbead_guess = (3/(4*pi)*Vbead_guess)^(1/3);
cutoff = 3*rbead_guess;
if isprefetch('verletList')
    load(prefetchvar('verletList'))
else
    [verletList,cutoff,dmin,config,dist] = buildVerletList(fluidxyz0,cutoff);
    save(prefetchvar('verletList'),'verletList','cutoff','dmin','config','dist')
end
rbead = dmin/2;
s = 2*rbead; % separation distance
h = 2*s;     % smoothing length

%% load the frame closest to simulation time: tframe
% with the mini dataset, are available:
% 0.30s 0.40s 0.45s 0.50s 0.55s 0.60s 0.65s 0.70s 0.75s 0.80s 0.85s 0.90s 0.95s 1.00s 1.05s 1.10s 
% tframelist = [0.3 0.4 0.45:0.05:1.10]; % verysmalldumps
tframelist = 0.1:0.01:1.1; % updated time frames
if ~exist('tframe','var')
    tframe = 0.85; %0.55; % s <-------------------- select time here
else
    tframe = tframelist(nearestpoint(tframe,tframelist)); % restrict to existing tframes
end
iframe = nearestpoint(tframe,times); % closest index
Xframe = lamdumpread2(dumpfile,'usesplit',[],timesteps(iframe));
Xframe.ATOMS.isfluid = Xframe.ATOMS.type==fluidtype;
Xframe.ATOMS.ispillar = Xframe.ATOMS.type==pillartype;
Xframe.ATOMS.issphere = Xframe.ATOMS.type==spheretype;
Xframe.ATOMS.issolid = Xframe.ATOMS.type==spheretype | Xframe.ATOMS.type==pillartype;
fluidxyz = Xframe.ATOMS{Xframe.ATOMS.isfluid,coords};
fluidid = X0.ATOMS{Xframe.ATOMS.isfluid,'id'};
pillarxyz = Xframe.ATOMS{Xframe.ATOMS.ispillar,coords};
pillarid = X0.ATOMS{Xframe.ATOMS.ispillar,'id'};
spherexyz = Xframe.ATOMS{Xframe.ATOMS.issphere,coords};
sphereid = X0.ATOMS{Xframe.ATOMS.issphere,'id'};
solidxyz = Xframe.ATOMS{Xframe.ATOMS.issolid,coords};
solidid = X0.ATOMS{Xframe.ATOMS.issolid,'id'};
ztop = max(pillarxyz(:,3)); % pillar top

%% Interpolate velocity field at z = ztop
% full box (note that atoms may be outside of this box)
box = Xframe.BOX(icoords,:); % note that the order is given by coords, here {'z'}    {'x'}    {'y'}
boxsize = diff(box,1,2);
% fluidbox (box for atoms to consider)
xmin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{1}});
xmax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{1}});
ymin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{2}});
ymax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{2}});
zmin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{3}});
zmax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{3}});
fluidbox = [xmin xmax;ymin ymax;zmin zmax];
% restrict interpolation to the viewbox
viewbox = fluidbox; viewbox(3,:) = [ztop-2*h ztop+2*h];
insideviewbox = true(height(Xframe.ATOMS),1);
for icoord = 1:3
    insideviewbox = insideviewbox ...
        & Xframe.ATOMS{:,coords{icoord}}>=viewbox(icoord,1) ...
        & Xframe.ATOMS{:,coords{icoord}}<=viewbox(icoord,2);
end
XYZ  = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.isfluid,coords};  % fluid kernel centers
vXYZ = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.isfluid,vcoords}; % velocity of fluid kernel centers
XYZs = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.issolid,coords};  % solid kernel centers
rhobeadXYZ = Xframe.ATOMS.c_rho_smd(insideviewbox & Xframe.ATOMS.isfluid); % volume of the bead

% force incell (this step is needed to apply PBC)
XYZ = PBCincell(XYZ,box,[true,true,false]);
XYZs = PBCincell(XYZs,box,[true,true,false]);

% add PBC images
[XYZimagesONLY ,indXimagesONLY]= PBCimages(XYZ,box,[true,true,false],2*h);
figure, hold on, plot3D(XYZ,'go')
plot3D(XYZ(indXimagesONLY,:),'go','markerfacecolor','g')
plot3D(XYZimagesONLY,'ro','markerfacecolor','r'), view(3), axis equal, view(2)
XYZwithImages = [XYZ;XYZimagesONLY];
vXYZwithImages = [vXYZ;vXYZ(indXimagesONLY,:)];
rhobeadXYZwithImages = [rhobeadXYZ;rhobeadXYZ(indXimagesONLY)];
VbeadXYZwithImages = mbead./rhobeadXYZwithImages;
isImages = true(size(XYZwithImages,1),1); isImages(1:size(XYZ,1))=false;

% interpolation grid (central grid, no images)
nresolution = [1024 1024 1];
xw = linspace(box(1,1),box(1,2),nresolution(1));
yw = linspace(box(2,1),box(2,2),nresolution(1));
zw = ztop;
[Xw,Yw,Zw] = meshgrid(xw,yw,zw);
XYZgrid = [Xw(:),Yw(:),Zw(:)];

% grid neighbors (incl. images) for interpolation and discarding grid points overlapping solid
if isprefetch('VXYZ')
    load(prefetchvar('VXYZ'))
else
    VXYZ  = buildVerletList({XYZgrid XYZwithImages},1.2*h);  % neighbors = fluid particles
    VXYZs = buildVerletList({XYZgrid XYZs},0.85*s); % neighbors = solid particles
    save(prefetchvar('VXYZ'),'VXYZ','VXYZs')
end
icontactsolid = find(cellfun(@length,VXYZs)>0);
VXYZ(icontactsolid) = repmat({[]},length(icontactsolid),1);

% interpolation on the grid of the 3D velocity (central grid)
% Do not forget even if we are applying a 2D interpretation, we use a 3D simulation
% 3D velocity are projected on 2D streamlines even if the projection of the 3rd component is 0
W = kernelSPH(h,'lucy',3); % kernel expression
if isprefetch('v3XYZgrid')
    load(prefetchvar('v3XYZgrid'))
else
    v3XYZgrid = interp3SPHVerlet(XYZwithImages,vXYZwithImages,XYZgrid,VXYZ,W,VbeadXYZwithImages);
    save(prefetchvar('v3XYZgrid'),'v3XYZgrid')
end
vxXYZgrid = reshape(v3XYZgrid(:,1),size(Xw)); %vxXYZgrid(isnan(vxXYZgrid)) = 0;
vyXYZgrid = reshape(v3XYZgrid(:,2),size(Xw)); %vyXYZgrid(isnan(vyXYZgrid)) = 0;
vzXYZgrid = reshape(v3XYZgrid(:,3),size(Xw)); %vzXYZgrid(isnan(vzXYZgrid)) = 0;
vXYZgrid  = reshape(sqrt(sum(v3XYZgrid.^2,2)),size(Xw));

% density on the grid (with a possible different h)
if isprefetch('rhobeadXYZgrid')
    load(prefetchvar('rhobeadXYZgrid'))
else
    rhobeadXYZgrid = interp3SPHVerlet(XYZwithImages,rhobeadXYZwithImages,XYZgrid,VXYZ,W,VbeadXYZwithImages);
    save(prefetchvar('rhobeadXYZgrid'),'rhobeadXYZgrid')
end
rhobeadXYZgrid = reshape(rhobeadXYZgrid,size(Xw));

% add PBC (add periodic PBC)
[vxXYZPBC,XwPBC,YwPBC] = PBCgrid(Xw,Yw,vxXYZgrid,[true,true],boxsize(1:2)./[8;2]);
rhobeadXYZPBC = PBCgrid(Xw,Yw,rhobeadXYZgrid,[true,true],boxsize(1:2)./[8;2]);
xwPBC = XwPBC(1,:); ywPBC = YwPBC(:,1)';
fluidboxPBC = double([xwPBC([1 end]);ywPBC([1 end]);fluidbox(3,:)]);
fluidboxsizePBC = diff(fluidboxPBC,1,2);
vyXYZPBC = PBCgrid(Xw,Yw,vyXYZgrid,[true,true],boxsize(1:2)./[8;2]);
vzXYZPBC = PBCgrid(Xw,Yw,vzXYZgrid,[true,true],boxsize(1:2)./[8;2]);
vXYZPBC = sqrt(vxXYZPBC.^2 + vyXYZPBC.^2 + vzXYZPBC.^2);
figure, mesh(XwPBC,YwPBC,vXYZPBC), axis equal, view(2), colorbar, title(sprintf('t=%0.3f s - velocity (m/s)',tframe))
figure, mesh(XwPBC,YwPBC,rhobeadXYZPBC); axis equal, view(2), colorbar, title(sprintf('t=%0.3f s - density (kg/m3)',tframe))

%% Plot (attention 2D, meshgrid convention)
figure, hold on
% velocity magnitude
imagesc(xwPBC,ywPBC,vXYZPBC)
axis tight, axis equal
colorbar
title(sprintf('t=%0.3f s - velocity (m/s)',tframe))

% quiver configuration and plot (boundaries are with PBC)
stepPBC = 16;
boundariesPBC = ...
             [ nearestpoint(double(xwPBC([1,end]))+fluidboxsizePBC(1)/100*[1 -1],double(xwPBC)) % x
               nearestpoint(double(ywPBC([1,end]))+fluidboxsizePBC(2)/100*[1 -1],double(ywPBC)) % y
             ];
indxquiver = boundariesPBC(1,1):stepPBC:boundariesPBC(1,2); % x indices
indyquiver = boundariesPBC(2,1):stepPBC:boundariesPBC(2,2); % y indices
quiver(XwPBC(indyquiver,indxquiver),YwPBC(indyquiver,indxquiver), ...
          vxXYZPBC(indyquiver,indxquiver),vyXYZPBC(indyquiver,indxquiver), ...
        'color','k','LineWidth',1)


%% streamlines
% UP from bottom (starting position) to top
% DOWN from top to bottom (same starting position by reversing the velocity field)
% assembled as [flipud(DOWN(2:end,:));UP]
% CELL streamlines along a y period, the separation distance is added to avoid gap

% streamline configuration and plot
boundaries = [ nearestpoint(double(xw([1,end])),double(xwPBC))
               nearestpoint(double(yw([1,end])),double(ywPBC))
             ];
step = 8;
indxstreamline = boundaries(1,1):step:boundaries(1,2);
indystreamline = boundaries(2,1):step:boundaries(2,2);
nstreamlines = length(indxstreamline);

% Generative streamlines
ngenerations = 4*2;
iygen = unique(round(linspace(indystreamline(1),indystreamline(end),ngenerations)));
ngenerations = length(iygen);
[verticesgenUP,verticesgenDOWN,verticesgen,verticesgenCELL,verticesgenCELLid] = deal({});
validstreamline = @(v) (v(:,2)-v(1,2))<=(boxsize(2)*1.5) & (v(:,2)-v(1,2))>=(boxsize(2)*0.01); % longer than 1% but not exceeding 150%
for igen = 1:ngenerations
    % ith generation of stream line (from indystreamline(1))
    dispf('generates the %dth of %d generation of streamlines',igen,ngenerations)
    xshift = double(mod(igen-1,2)*(xwPBC(indxstreamline(2))-xwPBC(indxstreamline(1))));
    [startgenX,startgenY,startgenZ] = meshgrid(...
        double(xwPBC(indxstreamline))+xshift,...
        double(ywPBC(iygen(igen))),double(ztop));
    verticesgenUP{igen} = stream2(double(XwPBC),double(YwPBC),vxXYZPBC,vyXYZPBC,startgenX,startgenY,[0.03 5e4]);
    verticesgenDOWN{igen} = stream2(double(XwPBC),double(YwPBC),-vxXYZPBC,-vyXYZPBC,startgenX,startgenY,[0.03 5e4]);
    verticesgen{igen} = cellfun(@(d,u) [flipud(d(2:end,:)); u],verticesgenDOWN{igen},verticesgenUP{igen},'UniformOutput',false);
    verticesgen{igen} = cellfun(@(v) v(~isnan(v(:,2)),:),verticesgen{igen},'UniformOutput',false);
    verticesgenCELL{igen} = cellfun(@(v) v(validstreamline(v),:),verticesgen{igen},'UniformOutput',false);
    verticesgenCELLid{igen} = igen*ones(1,length(verticesgenCELL{igen}));
end

% merge all verticesCELL
verticesCELL = cat(2,verticesgenCELL{:});
verticesCELLid = cat(2,verticesgenCELLid{:});
okverticesCELL = cellfun(@length,verticesCELL)>100; % remove empty and too short streamlines (as a result of filtering by validstreamline)
verticesCELL = verticesCELL(okverticesCELL);
verticesCELLid = verticesCELLid(okverticesCELL);

% retrieve the separation distance
sLagrangian = startgenX(1,2,1) - startgenX(1,1,1); % separation distance between streamlines at injection/starting
rLagrangian = sLagrangian/2;


% detect interruption (for control)
% yfinalposition1UP = cellfun(@(v) v(end,2),vertices1UP);
% yfinalposition1DOWN = cellfun(@(v) v(end,2),vertices1DOWN);
% isinterrupted1 = isnan(yfinalposition1UP) | isnan(yfinalposition1DOWN);

% control plot
figure, hold on
imagesc(xwPBC,ywPBC,vXYZPBC)
colors = jet(ngenerations);

for igen = 1:ngenerations
    for i=1:nstreamlines
        plot(verticesgen{igen}{i}(:,1),verticesgen{igen}{i}(:,2),'-','LineWidth',0.5,'color',colors(igen,:))
        plot(verticesgenCELL{igen}{i}(:,1),verticesgenCELL{igen}{i}(:,2),'-','linewidth',1,'color',colors(igen,:));
    end
end
axis equal
title(sprintf('t=%0.3f s - streamlines',tframe))

%% Distribute beads along streamlines tagged as CELL
% Once PBC are applied, space is filled with possibly overlaping streamlines
% the control plot is showing this effect


traj = fillstreamline2(verticesCELL,XwPBC,YwPBC,vxXYZPBC,vyXYZPBC,rLagrangian,0);
ntraj = length(traj);
%trajUP = fillstreamline2(verticesUPCELL,XwPBC,YwPBC,vxXYZPBC,vyXYZPBC,rLagrangian,0);
%traj(~isinterrupted) = trajUP(~isinterrupted);
XYZbeads = arrayfun(@(t) t.cart_distribution,traj,'UniformOutput',false);
% we apply PBC while keeping the id of the streamline
[XYZbeadsPBC,XYZbeadsPBCid] = deal(cell(ntraj,1));
for itraj=1:ntraj % trajectories and streamlines are assumed equivalent at steady state
    XYZbeadsPBC{itraj} = PBCincell(XYZbeads{itraj},box(1:2,:),[true true]); % wrapping along PBC
    XYZbeadsPBCid{itraj} = ones(size(XYZbeadsPBC{itraj},1),1)*verticesCELLid(itraj);
end

% control plots
figure, hold on
colors = tooclear(jet(ntraj));
for itraj = 1:ntraj
    plot(XYZbeadsPBC{itraj}(:,1),XYZbeadsPBC{itraj}(:,2),'o','markerfacecolor',colors(itraj,:),'markeredgecolor',colors(itraj,:))
end
title(sprintf('t=%0.3f s - colors match streamline index',tframe))

figure, hold on
colors = tooclear(jet(ngenerations));
for itraj = 1:ntraj
    plot(XYZbeadsPBC{itraj}(:,1),XYZbeadsPBC{itraj}(:,2),'o','markerfacecolor',colors(XYZbeadsPBCid{itraj}(1),:),'markeredgecolor',colors(XYZbeadsPBCid{itraj}(1),:))
end
title(sprintf('t=%0.3f s - colors match generation index',tframe))

%% remove duplicated beads between streamlines (too close)
% defined as beads from another streamline located at less than rbead
% this version incorporate the effect of the generational distance (somekind of age)
% beads from other injections points should emerge from positions farther from first generations (older ones)
% the generation index starts from the source of the flow (bottom), using streamlines from other positions is discouraged (since younger)
% 
% Note: streamlines are indexed from oldest (closest to the source) to youngest (farthest from the source)

% beads from different streamlines
for i=1:ntraj % reference streamline (higher precedence)
    for j=1:ntraj % the other streamline
        if i~=j
            indj = find(~isnan(XYZbeadsPBC{j}(:,1)));
            dij=pdist2(XYZbeadsPBC{i},XYZbeadsPBC{j}(indj,:)); % Euclidian distance
            % the criterion on age is too strict
            %dgenij = pdist2(XYZbeadsPBCid{i},XYZbeadsPBCid{j}(indj,:)); % generational distance (0 for the same generation)
            %XYZbeadsPBC{j}(indj(any(dij
            XYZbeadsPBC{j}(indj(any(dijend
    end
end

% beads from the same streamline
% two populations of beads are created (those inside and those outside (images) that could overlap those inside when they coordinates are wrapped)
%
% Note: we do not consider the overlapping of north and south images (the total height of a streamline is considered not to exceed 150% of the box height)
for i=1:ntraj
    isoutside =  (XYZbeads{i}(:,1)box(1,2)) | ...
                 (XYZbeads{i}(:,2)box(2,2) );
    isvalid = ~isnan(XYZbeadsPBC{i}(:,1));
    ioutside = find(isoutside & isvalid);  % these beads are possible images of beads already inside
    iinside =  find(~isoutside & isvalid); % these beads have higher precedence, they are already inside
    divsout=pdist2(XYZbeadsPBC{i}(iinside,:),XYZbeadsPBC{i}(ioutside,:));
    XYZbeadsPBC{i}(ioutside(any(divsoutend

XYZbeadsPBCall = cat(1,XYZbeadsPBC{:});
XYZbeadsPBCidall = cat(1,XYZbeadsPBCid{:});
isPBCallok = ~isnan(XYZbeadsPBCall(:,1));
XYZbeadsPBCall = XYZbeadsPBCall(isPBCallok,:);
XYZbeadsPBCidall = XYZbeadsPBCidall(isPBCallok,:);

% control while keeping the generational index
hfig = fighandle('packing');  hold on
colors = tooclear(hsv(ngenerations)); %turbo
for igen=1:ngenerations
    viscircles(XYZbeadsPBCall(XYZbeadsPBCidall==igen,:),rLagrangian,'color',colors(igen,:));
end
title(sprintf('t=%0.3f s - one color per injection line',tframe)), axis equal

PRINTON = true;
if PRINTON, printhandle(hfig), end

%% Filtering: remove overlapping from different injections using a first estimate of density

% Summary
% This methodology effectively redistributes beads to ensure that local densities do not exceed
% the physical limits of the simulation, enhancing realism and accuracy. By adjusting bead 
% distributions based on calculated densities and employing PBC to handle edge cases, the script 
% ensures a uniformly plausible representation of bead distributions across the simulation domain.

hfilter = 4*rLagrangian;
XYbeadsfilterid = XYZbeadsPBCidall;
XYbeadsfilter = XYZbeadsPBCall; 
nfilter = size(XYbeadsfilter,1);
XYbeadsfilter_images= PBCimages(XYbeadsfilter,box(1:2,:),[true,true],2*hfilter);
XYbeadsfilterwithImages = [XYbeadsfilter;XYbeadsfilter_images];
Vbeadsfilter = buildVerletList(XYbeadsfilter,hfilter);
VbeadsfilterBC = buildVerletList({XYbeadsfilter XYbeadsfilterwithImages},hfilter);
Volfilter = length(find(~isnan(rhobeadXYZgrid(:))))/numel(rhobeadXYZgrid) * boxsize(1) * boxsize(2) * s;
mfilter = rho*Volfilter/size(XYbeadsfilter,1); % mass of a single bead (informed)
Vfilter = mfilter/rho;
Wfilter = kernelSPH(hfilter,'lucy',2);
rhofilter = interp2SPHVerlet(...
    XYbeadsfilterwithImages,...
    rho*ones(size(XYbeadsfilterwithImages,1),1),...
    XYbeadsfilter,VbeadsfilterBC,Wfilter,Vfilter)/s; 

% target
rhomax = 1500;
ok = rhofilter<=rhomax;

% before
hfig = fighandle('packing_rhomax');  hold on
viscircles(XYbeadsfilter(ok,:),rLagrangian,'color','b');
viscircles(XYbeadsfilter(~ok,:),rLagrangian,'color','r');
title(sprintf('t=%0.3f s - in red: excess density',tframe)), axis equal


PRINTON = true;
if PRINTON, printhandle(hfig), end

% do filter
itoohigh = find(~ok);
[rhotoohigh,ind] = sort(rhofilter(itoohigh),'descend');
itoohigh = itoohigh(ind);
kept = true(nfilter,1);
for k=1:length(itoohigh)
    % valid neighbors (only)
    jBC = VbeadsfilterBC{itoohigh(k)}; % it includes self with images
    njBC = length(jBC);
    j = Vbeadsfilter{itoohigh(k)}; % it includes self without images
    j = j(kept(j));
    [idj,ind] = sort(XYbeadsfilterid(j),'ascend');
    j = j(ind);  nj = length(j);
    jdeletable = j(find(idj>min(idj),1,'first'):end); % we keep the first type
    [rhojdeletable,ind] = sort(rhofilter(jdeletable),'descend');
    jdeletable = jdeletable(ind); njdeletable = length(jdeletable);
    njexcess = floor( (1 - rhomax/rhotoohigh(k)) * njBC );
    kept(jdeletable(1:min(njexcess,njdeletable))) = false;
end

% after
hfig = fighandle('packing_rhomax_fix');  hold on
viscircles(XYbeadsfilter(kept,:),rLagrangian,'color','g');
viscircles(XYbeadsfilter(~kept,:),rLagrangian,'color','r');
title(sprintf('t=%0.3f s - in red: removed beads',tframe)), axis equal

if PRINTON, printhandle(hfig), end



%% calculate density
XYinformed = PBCincell(XYZbeadsPBCall(kept,:),box,[true true]); % PBC just to be sure
ninformed = size(XYinformed,1);
rinformed = rLagrangian; %radius
sinformed = 2*rinformed; % separation distance
hinformed = 5*sinformed; % for integration

% add PBC images
[XYinformed_images ,indimages]= PBCimages(XYinformed,box(1:2,:),[true,true],2*hinformed);
XYinformedwithImages = [XYinformed;XYinformed_images];
% Verlet list for the original grid
XYgrid = [Xw(:) Yw(:)];
if isprefetch('VXYinformed')
    load(prefetchvar('VXYinformed'))
else
    VXYinformed  = buildVerletList({XYgrid XYinformedwithImages},hinformed);
    save(prefetchvar('VXYinformed'),'VXYinformed')
end
% Verlet list for the informed beads
if isprefetch('VXYbeadinformed')
    load(prefetchvar('VXYbeadinformed'))
else
    VXYbeadinformed = buildVerletList({XYinformed XYinformedwithImages},hinformed);
    save(prefetchvar('VXYbeadinformed'),'VXYbeadinformed')
end
   

% Calculate the mass of informed beads
% total volume of fluid in the image
Volinformed = length(find(~isnan(rhobeadXYZgrid(:))))/numel(rhobeadXYZgrid) * boxsize(1) * boxsize(2) * s;
mbeadinformed = rho*Volinformed/ninformed; % mass of a single bead (informed)

% 2D Kernel
Winformed = kernelSPH(hinformed,'lucy',2); % kernel expression [/m2]

% Calculate the volume of the beads
Vbeadinformedguess = mbeadinformed/rho; % first guess
% density at the centers of the informed beads
rhobeadinformed = interp2SPHVerlet(XYinformedwithImages,rho*ones(size(XYinformedwithImages,1),1),XYinformed,VXYbeadinformed,Winformed,Vbeadinformedguess);
rhobeadinformed = rhobeadinformed/s;
% rhobeadinformed(rhobeadinformed<200) = NaN;
% rhobeadinformed(isnan(rhobeadinformed)) = median(rhobeadinformed,'omitmissing'); 

% volume of the informed beads
Vbeadinformed = mbeadinformed./rhobeadinformed;
% normalized radius of informed beads
rbeadinformed = sqrt(Vbeadinformed/(s*pi));
rbeadinformed = rbeadinformed/median(rbeadinformed,'omitmissing') * rLagrangian;
% control figure
figure, viscircles(XYinformed,rLagrangian,'color','g'), axis equal, hold on
viscircles(XYinformed,rbeadinformed,'color','r')

% reference density at the same positions
XYZeqinformed = [XYinformed ones(ninformed,1)*ztop];
VXYZeqinformed  = buildVerletList({XYZeqinformed XYZwithImages},1.2*h);
rhobeadXYZ2XYinformed = interp3SPHVerlet(XYZwithImages,rhobeadXYZwithImages,XYZeqinformed,VXYZeqinformed,W,VbeadXYZwithImages);

% density on the grid
if isprefetch('dgrid')
    load(prefetchvar('dgrid'))
else
    dgrid = interp2SPHVerlet(XYinformedwithImages,rho*ones(size(XYinformedwithImages,1),1),XYgrid,VXYinformed,Winformed,Vbeadinformedguess);
    save(prefetchvar('dgrid'),'dgrid')
end
dgrid = reshape(dgrid/s,size(Xw)); % /s to get in kg/m3 from kg/m2
dgrid(isnan(rhobeadXYZgrid)) = NaN; % we mask the objects (pillar and sphere) the same way as in the reference


%% ---------------------------- PRODUCTION FIGURES
hfig = []; close all

% Density mapped on beads
hfig(end+1) = fighandle('d_bead_informed'); hold on, title(sprintf('[t=%0.3g s] density mapped to informed beads',tframe))
scatter(XYinformed(:,1),XYinformed(:,2),100*(rbeadinformed/min(rbeadinformed)).^2,rhobeadinformed,'filled'), colorbar
hfig(end+1) = fighandle('d_bead_reference'); hold on, title(sprintf('[t=%0.3g s] reference density mapped to informed beads',tframe))
scatter(XYZeqinformed(:,1),XYZeqinformed(:,2),100*(rbeadinformed/min(rbeadinformed)).^2,rhobeadXYZ2XYinformed,'filled'), colorbar
hfig(end+1) = fighandle('d_bead_informed_vs_reference'); plot(rhobeadXYZ2XYinformed(:),rhobeadinformed(:),'ro'), xlabel('reference density (back mapped)'), ylabel('informed density')
title(sprintf('[t=%0.3g s] informed vs. reference density',tframe))

% density mapped on the grid
hfig(end+1) = fighandle('d_grid_informed'); hp = pcolor(xw,yw,dgrid); hp.EdgeColor = 'none'; colorbar, title(sprintf('[t=%0.3g s] informed density (kg/m3)',tframe)), axis equal %, clim([500 1300])
haxtomodify = gca;
hfig(end+1) = fighandle('d_grid_reference'); hp = pcolor(xw,yw,rhobeadXYZgrid); hp.EdgeColor = 'none'; colorbar, title(sprintf('[t=%0.3g s] reference density (kg/m3)',tframe)), axis equal %, clim([500 1300])
clim(haxtomodify,clim)

% distribution of densities
hfig(end+1) = fighandle('distribution_rho');  hold on
histogram(rhobeadinformed), histogram(rhobeadXYZ2XYinformed), legend({'informed density','reference density'})
title(sprintf('[t=%0.3g s] Density distributions',tframe))


%% -- identify the beads in contact with objects based on density
% SUMMARY.
% This section outlines a methodology for identifying beads in contact with solid objects
% in a fluid simulation, particularly focusing on density-based criteria to determine close
% interactions and potential contact forces.

% Attention the sphere can exceed the area observed (overflow condition)
% Safe coordinates are only use for contour identification
isynan = isnan(mean(rhobeadXYZgrid(:,floor(size(rhobeadXYZgrid,2)*0.6):end),2));
isoverflow =  (find(isynan,1,'last')-find(isynan,1,'first')+1)==size(rhobeadXYZgrid,1);
if (find(isynan,1,'last')-find(isynan,1,'first')+1)==size(rhobeadXYZgrid,1) % reach top
    iyoverflow = find(~isynan,1,'first');
    iymargin = round(size(rhobeadXYZgrid,1)*0.1); % margin to add
    iysafe = iyoverflow+iymargin;          % index translation (along y)
    dysafe = -iysafe * ( Yw(2,1)-Yw(1,1) ); % distance translation (along y)
    [rXYgridsafe,Xwsafe,Ywsafe] = PBCgridshift(Xw,Yw,rhobeadXYZgrid,[0 iysafe]); % translate
    dgridsafe = PBCgridshift(Xw,Yw,dgrid,[0 iysafe]); % translate
    [XYinformedsafe,boxsafe] = PBCimagesshift(XYinformed,[0 dysafe],box(1:2,1:2));
elseif find(isynan,1,'first')==1
    iymargin = round(size(rhobeadXYZgrid,1)*0.1); % margin to add
    iyoverflow = iymargin;
    if isynan(end), iyoverflow = iyoverflow + length(iyoverflow)-find(~isynan,1,'last'); end
    iysafe = -iyoverflow;
    dysafe = -iysafe * ( Yw(2,1)-Yw(1,1) ); % distance translation (along y)
    [rXYgridsafe,Xwsafe,Ywsafe] = PBCgridshift(Xw,Yw,rhobeadXYZgrid,[0 iysafe]); % translate
    dgridsafe = PBCgridshift(Xw,Yw,dgrid,[0 iysafe]); % translate
    [XYinformedsafe,boxsafe] = PBCimagesshift(XYinformed,[0 dysafe],box(1:2,1:2));
else
    dysafe = 0;
    [rXYgridsafe,Xwsafe,Ywsafe] = deal(rhobeadXYZgrid,Xw,Yw);
    [dgridsafe,XYinformedsafe,boxsafe] = deal(dgrid,XYinformed,box);
end

% Volume of objects (GRID points): XYobjects where density is NaN vy definition
XYobjects = [Xwsafe(:) Ywsafe(:)];
XYobjects = XYobjects(isnan(rXYgridsafe),:);
% Looking for beads in contact with XYobjects (grid points)
V2 = buildVerletList({XYinformedsafe XYobjects},3*sinformed);
% Index of beads in contact with XYobjects (grid points)
icontact = find(cellfun(@length,V2)>0);
XYcontact = double(XYinformedsafe(icontact,:));
% Enclosed beads
k = boundary(XYcontact,1); nk = length(k);
XYcontactk = XYcontact(k,:);

% separation of the objects, contour parameterization, tangents, normals
% the pillar is assumed fixed
pillarcenter = [2.87,3.08]*1e-4; % 0.2880e-3    0.3131e-3, mean(objects(1).XY)
ispillar = vecnorm(XYcontactk - pillarcenter,2,2)<0.8e-4; %  7.7859e-05, max(vecnorm(XYcontactk(ispillar,:) - pillarcenters,2,2))
objects = struct('XY',{XYcontactk(ispillar,:) XYcontactk(~ispillar,:)},'marker',{'bo','ms'},'line',{'b-','m-'},'color',{'b','m'});
anglestep = pi/32;
angles = (-pi:anglestep:pi)';
for k = 1:length(objects)
    % fit each object as a circle to try to close the boundaries
    objects(k).fit = fitCircleFromPoints(objects(k).XY);
    missingangles = angles(abs(angles-objects(k).fit.angles(nearestpoint(angles,objects(k).fit.angles)))>anglestep);
    XYtoadd = objects(k).fit.XYgenerator(missingangles);
    XYclosed = [objects(k).XY;XYtoadd]; nXYclosed = floor(size(XYclosed,1)/2)*2;
    [anglesclosed,ind] = sort(objects(k).fit.angleGenerator(XYclosed));
    XYclosed = XYclosed (ind,:); % sort points according to angles
    % enforce periodic conditions along the index dimension
    objects(k).XYclosed = [XYclosed((nXYclosed/2+1):end,:) ; XYclosed ; XYclosed(1:(nXYclosed/2),:)];
    objects(k).n = size(objects(k).XYclosed,1);

    % First pass - contour twice longer than the real one
    % fit each obhect using a regularized spline approximation
    sp = csaps((1:objects(k).n)',objects(k).XYclosed',0.25); % smoothed cubic spline
    %sp = spaps((1:objects(k).n)',objects(k).XYclosed',0.001*sum(var(objects(k).XYclosed))*objects(k).n);
    spder = fnder(sp,1);

    % Second pass - approximation based on angles
    xycontours = fnval(sp,sp.breaks)';
    dxycontours = fnval(spder,sp.breaks)';
    xycircle = fitCircleFromPoints(xycontours);
    [xyangles,ind] = sort(xycircle.angles,'ascend');
    minangle = min(xyangles);
    maxangle = max(xyangles);
    xyangles = (2*(xyangles-minangle)/(maxangle-minangle)-1) * pi; % rescaled to close the figure
    xycontoursf = [ smooth(xyangles,xycontours(ind,1),0.15,'rloess'),...
                    smooth(xyangles,xycontours(ind,2),0.15,'rloess') ];
    dxycontoursf = [ smooth(xyangles,dxycontours(ind,1),0.15,'rloess'),...
                    smooth(xyangles,dxycontours(ind,2),0.15,'rloess') ];

    % Make all data unique
    [xyangles,ind] = unique(xyangles,'stable');
    xycontoursf = xycontoursf(ind,:);
    dxycontoursf = dxycontoursf(ind,:);
    xycontoursf([1 end],:) = [1;1] * mean(xycontoursf([1 end],:));
    dxycontoursf([1 end],:) = [1;1] * mean(dxycontoursf([1 end],:));

    % Third Pass using contour length instead of angle as variable
    % ATTENTION: for averaging it is preferable to use curvilinear coordinates
    lxycontour = [0; cumsum(sqrt(sum(diff(xycontoursf,1,1).^2,2)))];
    sp2 = csaps(lxycontour',xycontoursf');


    % Extract tangents at prescribed curvilinear coordinates
    xp = linspace(lxycontour(1),lxycontour(end),objects(k).n)';
    % center and apparent radius (for visualizing the force acting on the object)
    objects(k).XYboundary = fnval(sp2,xp)';
    objects(k).center = mean(objects(k).XYboundary);
    objects(k).radius = min(vecnorm(objects(k).XYboundary-objects(k).center,2,2));
    % tangents (from the spline approximation)
    %objects(k).tangents = ndf(xp,objects(k).XYboundary,1,[],'makeuniform',true); %curve2tangent(objects(k).XYboundary); %fnval(fnder(sp2,1),xp)';
    objects(k).tangents = fnval(fnder(sp2,1),xp)';
    objects(k).tangents = objects(k).tangents./vecnorm(objects(k).tangents,2,2); % Normalize the tangent vectors
    % normals (turn the normals to be inwards using inpolygon)
    objects(k).normals = [-objects(k).tangents(:,2),objects(k).tangents(:,1)]; % % Calculate the centroid of the shape
    testPoints = objects(k).XYboundary + 0.01 * objects(k).radius * objects(k).normals; % Choose a test point slightly offset from each boundary point along the normal
    isInside = inpolygon(testPoints(:,1), testPoints(:,2),...
        objects(k).XYboundary(:,1), objects(k).XYboundary(:,2)); % Use inpolygon to check if each test point is inside the shape
    objects(k).normals(~isInside, :) = -objects(k).normals(~isInside, :); % Flip the normals where the test point is outside the shape
    % add density, pressure information (look for the nearest beads closest to the boundary, average the value)
    objects(k).Vcontact = buildVerletList({objects(k).XYboundary XYcontact},3*sinformed);
    objects(k).Vcontact = cellfun(@(v) icontact(v)',objects(k).Vcontact,'UniformOutput',false); % Vcontact{i} index of beads in contact with XYboundary(i,:)
    objects(k).rhocontact = cellfun(@(v) mean(rhobeadinformed(v)),objects(k).Vcontact);
    objects(k).Pcontact = 1 + (objects(k).rhocontact/rho).^7-1; % reduced pressure P/B with P0/B=1
    objects(k).densitynormals = objects(k).rhocontact.*objects(k).normals/rho;
    objects(k).avdensitynormals = mean(objects(k).densitynormals,'omitmissing');
    objects(k).pressurenormals = objects(k).Pcontact.*objects(k).normals;
    objects(k).avpressurenormals = mean(objects(k).pressurenormals,'omitmissing');
end

% plot
hfig(end+1) = fighandle('distribution_forces');  hold on
set(hfig(end),'PaperPosition',[ -2.0000    1.7000   30.0000   30.0000])
step = 2;
hp = pcolor(Xwsafe(1,:),Ywsafe(:,1),dgridsafe); hp.EdgeColor = 'none'; colorbar
quiv = struct('xy',[],'nxy',[],'mag',[],'nscale',2);
for k = 1:length(objects)
    % viscircles(XYcontact,rinformed,'color','r')
    % plot(objects(k).XY(:,1),objects(k).XY(:,2),objects(k).marker)
    % plot(objects(k).XYboundary(:,1),objects(k).XYboundary(:,2),objects(k).line,'linewidth',2,'marker','x')
    quiv.xy  = [quiv.xy;  objects(k).XYboundary(1:step:end,:);      objects(k).center];
    quiv.nxy = [quiv.nxy; objects(k).pressurenormals(1:step:end,:); quiv.nscale*objects(k).avpressurenormals];
    quiv.mag = [quiv.mag; objects(k).Pcontact(1:step:end);mean(objects(k).Pcontact,'omitmissing')];
end
% all quivers at once (color 
hq = quiver(quiv.xy(:,1),quiv.xy(:,2),quiv.nxy(:,1),quiv.nxy(:,2),3,'color','k','LineWidth',0.5);
SetQuiverColor(hq,tooclear(jet),'mags',quiv.mag,'range',[0 0.5])
axis equal, title(sprintf('[t=%0.3g s] Pressure around objects',tframe))

%% print
PRINTON = true;
if PRINTON
    for i=1:length(hfig)
        figure(hfig(i)), drawnow
        printhandle(hfig(i))
    end
end



% relative pressure via Tait equation
% Pref = (rhobeadXYZgrid./rho).^7 - 1; % reference pressure
% Pbead = (rhobeadinformed./rho).^7 - 1; % pressure at kernel positions
% Pgrid = (dgrid./rho).^7 - 1; % pressure at grid nodes
% Pgrid = min(Pref(:)) + (max(Pref(:))-min(Pref(:)))*(Pgrid-min(Pgrid(:)))/(max(Pgrid(:))-min(Pgrid(:)));
% figure, imagesc(xw,yw,Pgrid), colorbar, title('dimensionless pressure (-)'), axis equal
% clim([-1 3]), colorbar
% figure, imagesc(xw,yw,Pref), colorbar, title('reference dimensionless pressure (-)'), axis equal
% clim([-1 3]), colorbar
% figure, scatter(XYinformed(:,1),XYinformed(:,2),rbeadinformed,Pbead,'filled')

% Relative fluid-to-sphere velocity field
% rev. 2024/04/04

% 2024/04/02 fork of Billy_results_template_cross_section.m (version 2024/02/31)
% SUMMARY

%% initialization
close all
clearvars -except tframe tframelist PLOTON SAVEON OVERWRITE


%% Definitions

% tframe = 0.67; % central
% tframe = 0.57; % central-0.1
% tframe = 0.77; % central+0.1
% tframe = 0.62; % central-0.05
% tframe = 0.72; % central+0.05
% tframe = 0.15;
t0_ = clock;

% check folders
prefetchfolder = fullfile(pwd,'prefetch');
savefolder = fullfile(pwd,'results');
if ~exist(savefolder,'dir'), mkdir(savefolder); end

% Assign default values if needed
if ~exist('PLOTON','var'), PLOTON = true; end
if ~exist('SAVEON','var'), SAVEON = true; end
if ~exist('OVERWRITE','var'), OVERWRITE = false; end

% Some anaonymous functions
prefetchvar = @(varargin) fullfile(prefetchfolder,sprintf('t%0.4f_%s.mat',tframe,varargin{1}));
isprefetch = @(varargin) exist(prefetchvar(varargin{1}),'file');
savefile = @() fullfile(savefolder,sprintf('3DRt.%0.4f.mat',tframe));
dispsection = @(s) dispf('\n%s\ntframe=%0.4g s \t[  %s  ]   elapsed time: %4g s\n%s',repmat('*',1,120),tframe,regexprep(upper(s),'.','$0 '),etime(clock,t0_),repmat('*',1,120)); %#ok





%% path and metadata
dispsection('INITIALIZATION')
originalroot = '/media/olivi/T7 Shield/Thomazo_V2';
if exist(originalroot,'dir')
    root = originalroot;
    rootlocal = fullfile(pwd,'smalldumps');
    copymode = true;
else
    root = fullfile(pwd,'smalldumps');
    copymode = false;
end

simfolder = ...
    struct(...
    'A1',struct('artificial',...
'Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz',...
    'Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz' ...
                ),...
    'A2',struct('artificial',...
'./Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_2.tar.gz' ...
    ),...
    'B1',struct('Morris',...
'./Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft.tar.gz' ...
    ),...
    'B2',struct('Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_1.tar.gz' ...
    ),...
    'B3',struct('Morris',...
'/Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_2_3.tar.gz' ...
    ) ...
    );

% selection (not change it if you do not have the full dataset/hard disk attached to your system)
config = 'A1';
viscosity = 'Morris';
sourcefolder= fullfile(root,rootdir(simfolder.(config).(viscosity)));
sourcefile = regexprep(lastdir(simfolder.(config).(viscosity)),'.tar.gz$','');
dumpfile = fullfile(sourcefolder,sourcefile);
dispf('config: %s | viscosity: %s | source: %s',config,viscosity,dumpfile)

%% extract information
dispsection('OVERVIEW')
X0 = lamdumpread2(dumpfile); % first frame
natoms = X0.NUMBER;
timesteps = X0.TIMESTEPS;
X1 = lamdumpread2(dumpfile,'usesplit',[],timesteps(2));
dt = (X1.TIME-X0.TIME)/(timesteps(2)-timesteps(1)); % integration time step
times = double(timesteps * dt); % in seconds 
atomtypes = unique(X0.ATOMS.type);
ntimesteps = length(timesteps);
T = X0.ATOMS.type;
natomspertype = arrayfun(@(t) length(find(T==t)),atomtypes);
[~,ind] = sort(natomspertype,'descend');
% Thomazo simulation details
fluidtype  = ind(1);
pillartype = ind(2);
walltype   = ind(3);
spheretype = ind(4);
coords = {'z','x','y'}; % to match Thomazo's movies
vcoords = cellfun(@(c) sprintf('v%s',c),coords,'UniformOutput',false);
icoords = cellfun(@(c) find(ismember({'x','y','z'},c)),coords); %<- use this index for BOX
% Simulation parameters
% Billy choose a reference density of 900 kg/m3 for a physical density of 1000 kg/m3
% Viscosity: 0.13 Pa.s
mbead = 4.38e-12; % kg
rho = 1000; % kg / m3 (density of the fluid)
Vbead = mbead/rho;
dispf('SUMMARY: natoms: %d | dt: %0.3g s | rho: %0.4g',natoms,dt,rho)

%% Estimate bead size from the first frame
% first estimate assuming that the bead is a cube
dispsection('BEAD SIZE')
fluidxyz0 = X0.ATOMS{T==fluidtype,coords};
boxdims = X0.BOX(:,2) - X0.BOX(:,1);
Vbead_guess = prod(boxdims)/natoms;
rbead_guess = (3/(4*pi)*Vbead_guess)^(1/3);
cutoff = 3*rbead_guess;
if isprefetch('verletList')
    load(prefetchvar('verletList'))
else
    [verletList,cutoff,dmin,config,dist] = buildVerletList(fluidxyz0,cutoff);
    save(prefetchvar('verletList'),'verletList','cutoff','dmin','config','dist')
end
rbead = dmin/2;
s = 2*rbead; % separation distance
h = 2*s;     % smoothing length
dispf('SUMMARY: s: %0.4g m | h: %0.4g m',s,h)
%% load the frame closest to simulation time: tframe
% with the mini dataset, are available:
% 0.30s 0.40s 0.45s 0.50s 0.55s 0.60s 0.65s 0.70s 0.75s 0.80s 0.85s 0.90s 0.95s 1.00s 1.05s 1.10s 
% tframelist = [0.3 0.4 0.45:0.05:1.10]; % verysmalldumps
tframelist = 0.0:0.01:1.2; % updated time frames
if ~exist('tframe','var')
    tframe = 0.85; %0.55; % s <-------------------- select time here
else
    tframe = tframelist(nearestpoint(tframe,tframelist)); % restrict to existing tframes
end
iframe = nearestpoint(tframe,times); % closest index
Xframe = lamdumpread2(dumpfile,'usesplit',[],timesteps(iframe));
Xframe.ATOMS.isfluid = Xframe.ATOMS.type==fluidtype;
Xframe.ATOMS.ispillar = Xframe.ATOMS.type==pillartype;
Xframe.ATOMS.issphere = Xframe.ATOMS.type==spheretype;
Xframe.ATOMS.issolid = Xframe.ATOMS.type==spheretype | Xframe.ATOMS.type==pillartype;
box = Xframe.BOX(icoords,:); % note that the order is given by coords, here {'z'}    {'x'}    {'y'}
boxsize = diff(box,1,2);

%% Unwrap all coordinates
Pshift = [0 boxsize(2)/2 0];
PBC = [true true false];

spherexyz = Xframe.ATOMS{Xframe.ATOMS.issphere,coords};
spherebox = [min(spherexyz)' max(spherexyz)'];
sphereboxsize = diff(spherebox,1,2);
spherexyz_ = spherexyz; % initial position

if any(sphereboxsize>boxsize/2)
    disp('shift UP')
    Pshift = [0 boxsize(2)/2 0];
    XYZunwrapped =  unwrapPBC(PBCincell(Xframe.ATOMS{:,coords},box,PBC),Pshift,box,PBC);
    spherexyz = XYZunwrapped(Xframe.ATOMS.issphere,:);
    spherebox = [min(spherexyz)' max(spherexyz)'];
    sphereboxsize = diff(spherebox,1,2);
    if any(sphereboxsize>boxsize/2)
        Pshift = [0 -boxsize(2)/2 0];
        disp('shift DOWN')
        XYZunwrapped =  unwrapPBC(PBCincell(Xframe.ATOMS{:,coords},box,PBC),Pshift,box,PBC);
    end
else
    Pshift = [0 0 0];
    XYZunwrapped = Xframe.ATOMS{:,coords};
end
fluidxyz = XYZunwrapped(Xframe.ATOMS.isfluid,:);
spherexyz = XYZunwrapped(Xframe.ATOMS.issphere,:);
Pshiftactual = spherexyz_ - spherexyz;

%% Extract sphere properties
dispsection('SPHERE INFORMATION')
R01 = struct('tframe',tframe,'box',box,'boxdim',boxsize,'Pshift',Pshift,'Pshiftactual',mean(Pshiftactual,1),...
    'sphereXYZ0',[],'fluidXYZ',[],'vfluidXYZ',[],'fluidXYZ0',[],'vfluidXYZ0',[]);
R01.sphereXYZ0 = mean(spherexyz);
spherebox = [min(spherexyz)' max(spherexyz)'];
sphereboxdim = diff(spherebox,1,2);
viewbox = spherebox + [-0.25 0.25].*sphereboxdim;
viewboxsize = diff(viewbox,1,2);
insideviewbox = true(height(Xframe.ATOMS),1);
for icoord = 1:3
    insideviewbox = insideviewbox ...
        & XYZunwrapped(:,icoord)>=viewbox(icoord,1) ...
        & XYZunwrapped(:,icoord)<=viewbox(icoord,2);
end
XYZ  = XYZunwrapped(insideviewbox & Xframe.ATOMS.isfluid,:);  % fluid kernel centers
vXYZ = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.isfluid,vcoords}; % velocity of fluid kernel centers
Vcontact = buildVerletList({XYZ spherexyz},2*s);
iscontact = cellfun(@length,Vcontact)>0;
XYZcontact = XYZ(iscontact,:);
if PLOTON
    figure, hold on, plot3D(spherexyz,'ro','markerfacecolor','r'), plot3D(XYZ(iscontact,:),'bo','markerfacecolor','b'), plot3D(XYZ(~iscontact,:),'co','markerfacecolor','c'), view(3), axis equal
    drawnow
end
R01.fluidXYZ = XYZ(iscontact,:);
R01.fluidXYZ0 = mean(R01.fluidXYZ,1);
R01.vfluidXYZ = vXYZ(iscontact,:);
R01.vfluidXYZ0 = mean(R01.vfluidXYZ);

%% save
if SAVEON && (~exist(savefile(),'file') || OVERWRITE)
    save(savefile(),'R01')
end

% First template to retrieve Billy's paper 2 simulation data 
% rev. 2024/03/17 - forked in 2024/03/16 with PBC

% 2024/04/02 fork of Billy_results_template_PBC (version 2024/02/31)
% SUMMARY


%% Definitions
tframe = 0.67; % central
tframe = 0.57; % central-0.1
tframe = 0.77; % central+0.1
tframe = 0.62; % central-0.05
tframe = 0.72; % central+0.05
t0_ = clock;

% check folders
prefetchfolder = fullfile(pwd,'prefetch');
savefolder = fullfile(pwd,'results');
if ~exist(savefolder,'dir'), mkdir(savefolder); end

% Assign default values if needed
if ~exist('RESETPREFETCH','var'), RESETPREFETCH = false; end
if ~exist('PLOTON','var'), PLOTON = true; end
if ~exist('PRINTON','var'), PRINTON = false; end

% Some anaonymous functions
prefetchvar = @(varargin) fullfile(prefetchfolder,sprintf('t%0.4f_%s.mat',tframe,varargin{1}));
isprefetch = @(varargin) exist(prefetchvar(varargin{1}),'file') && ~RESETPREFETCH;
dispsection = @(s) dispf('\n%s\ntframe=%0.4g s \t[  %s  ]   elapsed time: %4g s\n%s',repmat('*',1,120),tframe,regexprep(upper(s),'.','$0 '),etime(clock,t0_),repmat('*',1,120)); %#ok
fighandle = @(id) formatfig(figure,'figname',sprintf('t%0.3g_%s',tframe,id));
printhandle = @(hfig) print_png(300,fullfile(outputfolder,[get(hfig,'filename') '.png']),'','',0,0,0);

% video recording parameters
fps = 10;
moviefolder = fullfile(rootdir(savefolder),'foodsim2024','movies');
moviefile = sprintf('crossection_t%0.4g.gif',tframe);
snapfile = sprintf('crossection_t%0.4g.png',tframe);
if ~exist(moviefolder,'dir'), mkdir(moviefolder), end
fullmoviefile = fullfile(moviefolder,moviefile);
fullsnapfile = fullfile(moviefolder,snapfile);
existmoviefile = @() exist(fullmoviefile,'file');
existsnapfile = @() exist(fullsnapfile,'file');
makemovie = @(hax) gif_add_frame(hax,fullmoviefile,fps);
makesnap = @() print_png(300,fullsnapfile,'','',0,0,0);

%% path and metadata
dispsection('INITIALIZATION')
originalroot = '/media/olivi/T7 Shield/Thomazo_V2';
if exist(originalroot,'dir')
    root = originalroot;
    rootlocal = fullfile(pwd,'smalldumps');
    copymode = true;
else
    root = fullfile(pwd,'smalldumps');
    copymode = false;
end

simfolder = ...
    struct(...
    'A1',struct('artificial',...
'Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz',...
    'Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz' ...
                ),...
    'A2',struct('artificial',...
'./Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_2.tar.gz' ...
    ),...
    'B1',struct('Morris',...
'./Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft.tar.gz' ...
    ),...
    'B2',struct('Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_1.tar.gz' ...
    ),...
    'B3',struct('Morris',...
'/Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_2_3.tar.gz' ...
    ) ...
    );

% selection (not change it if you do not have the full dataset/hard disk attached to your system)
config = 'A1';
viscosity = 'Morris';
sourcefolder= fullfile(root,rootdir(simfolder.(config).(viscosity)));
sourcefile = regexprep(lastdir(simfolder.(config).(viscosity)),'.tar.gz$','');
dumpfile = fullfile(sourcefolder,sourcefile);
dispf('config: %s | viscosity: %s | source: %s',config,viscosity,dumpfile)

%% extract information
dispsection('OVERVIEW')
X0 = lamdumpread2(dumpfile); % first frame
natoms = X0.NUMBER;
timesteps = X0.TIMESTEPS;
X1 = lamdumpread2(dumpfile,'usesplit',[],timesteps(2));
dt = (X1.TIME-X0.TIME)/(timesteps(2)-timesteps(1)); % integration time step
times = double(timesteps * dt); % in seconds 
atomtypes = unique(X0.ATOMS.type);
ntimesteps = length(timesteps);
T = X0.ATOMS.type;
natomspertype = arrayfun(@(t) length(find(T==t)),atomtypes);
[~,ind] = sort(natomspertype,'descend');
% Thomazo simulation details
fluidtype  = ind(1);
pillartype = ind(2);
walltype   = ind(3);
spheretype = ind(4);
coords = {'z','x','y'}; % to match Thomazo's movies
vcoords = cellfun(@(c) sprintf('v%s',c),coords,'UniformOutput',false);
icoords = cellfun(@(c) find(ismember({'x','y','z'},c)),coords); %<- use this index for BOX
% Simulation parameters
% Billy choose a reference density of 900 kg/m3 for a physical density of 1000 kg/m3
% Viscosity: 0.13 Pa.s
mbead = 4.38e-12; % kg
rho = 1000; % kg / m3 (density of the fluid)
Vbead = mbead/rho;
dispf('SUMMARY: natoms: %d | dt: %0.3g s | rho: %0.4g',natoms,dt,rho)

%% Estimate bead size from the first frame
% first estimate assuming that the bead is a cube
dispsection('BEAD SIZE')
fluidxyz0 = X0.ATOMS{T==fluidtype,coords};
boxdims = X0.BOX(:,2) - X0.BOX(:,1);
Vbead_guess = prod(boxdims)/natoms;
rbead_guess = (3/(4*pi)*Vbead_guess)^(1/3);
cutoff = 3*rbead_guess;
if isprefetch('verletList')
    load(prefetchvar('verletList'))
else
    [verletList,cutoff,dmin,config,dist] = buildVerletList(fluidxyz0,cutoff);
    save(prefetchvar('verletList'),'verletList','cutoff','dmin','config','dist')
end
rbead = dmin/2;
s = 2*rbead; % separation distance
h = 2*s;     % smoothing length
dispf('SUMMARY: s: %0.4g m | h: %0.4g m',s,h)
%% load the frame closest to simulation time: tframe
% with the mini dataset, are available:
% 0.30s 0.40s 0.45s 0.50s 0.55s 0.60s 0.65s 0.70s 0.75s 0.80s 0.85s 0.90s 0.95s 1.00s 1.05s 1.10s 
% tframelist = [0.3 0.4 0.45:0.05:1.10]; % verysmalldumps
tframelist = 0.0:0.01:1.2; % updated time frames
if ~exist('tframe','var')
    tframe = 0.85; %0.55; % s <-------------------- select time here
else
    tframe = tframelist(nearestpoint(tframe,tframelist)); % restrict to existing tframes
end
iframe = nearestpoint(tframe,times); % closest index
Xframe = lamdumpread2(dumpfile,'usesplit',[],timesteps(iframe));
Xframe.ATOMS.isfluid = Xframe.ATOMS.type==fluidtype;
Xframe.ATOMS.ispillar = Xframe.ATOMS.type==pillartype;
Xframe.ATOMS.issphere = Xframe.ATOMS.type==spheretype;
Xframe.ATOMS.issolid = Xframe.ATOMS.type==spheretype | Xframe.ATOMS.type==pillartype;
fluidxyz = Xframe.ATOMS{Xframe.ATOMS.isfluid,coords};
fluidid = X0.ATOMS{Xframe.ATOMS.isfluid,'id'};
pillarxyz = Xframe.ATOMS{Xframe.ATOMS.ispillar,coords};
pillarid = X0.ATOMS{Xframe.ATOMS.ispillar,'id'};
spherexyz = Xframe.ATOMS{Xframe.ATOMS.issphere,coords};
sphereid = X0.ATOMS{Xframe.ATOMS.issphere,'id'};
solidxyz = Xframe.ATOMS{Xframe.ATOMS.issolid,coords};
solidid = X0.ATOMS{Xframe.ATOMS.issolid,'id'};
ztop = max(pillarxyz(:,3)); % pillar top
spherebox = [min(spherexyz)' max(spherexyz)'];
halftoppillar = pillarxyz(:,3)>ztop/2;
pillarbox = [min(pillarxyz(halftoppillar,:))' max(pillarxyz(halftoppillar,:))'];
spherepillarbox = [ min(spherebox(:,1),pillarbox(:,1)) max(spherebox(:,2),pillarbox(:,2)) ]; spherepillarboxdim=diff(spherepillarbox,1,2);
viewbox3d = [(spherepillarbox(:,1)-[0.15;0.5;0].*spherepillarboxdim),...
    (spherepillarbox(:,2)+[0.15;0.5;0.02].*spherepillarboxdim)];


%% Interpolate velocity field at z = ztop
dispsection('REFERENCE VELOCITY FIELD')
% full box (note that atoms may be outside of this box)
box = Xframe.BOX(icoords,:); % note that the order is given by coords, here {'z'}    {'x'}    {'y'}
boxsize = diff(box,1,2);
% fluidbox (box for atoms to consider)
xmin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{1}});
xmax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{1}});
ymin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{2}});
ymax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{2}});
zmin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{3}});
zmax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{3}});
fluidbox = [xmin xmax;ymin ymax;zmin zmax];
% restrict interpolation to the viewbox
viewbox = viewbox3d; %fluidbox; viewbox(3,:) = [ztop-2*h ztop+2*h];
viewboxsize = diff(viewbox,1,2);
insideviewbox = true(height(Xframe.ATOMS),1);
for icoord = 1:3
    insideviewbox = insideviewbox ...
        & Xframe.ATOMS{:,coords{icoord}}>=viewbox(icoord,1) ...
        & Xframe.ATOMS{:,coords{icoord}}<=viewbox(icoord,2);
end
XYZall  = Xframe.ATOMS{Xframe.ATOMS.isfluid,coords};  % fluid kernel centers
vXYZall = Xframe.ATOMS{Xframe.ATOMS.isfluid,vcoords}; % velocity of fluid kernel centers
XYZ  = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.isfluid,coords};  % fluid kernel centers
vXYZ = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.isfluid,vcoords}; % velocity of fluid kernel centers
XYZp = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.ispillar,coords};  % solid kernel centers
XYZs = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.issphere,coords}; 
rhobeadXYZall = Xframe.ATOMS.c_rho_smd(Xframe.ATOMS.isfluid); % volume of the bead
rhobeadXYZ = Xframe.ATOMS.c_rho_smd(insideviewbox & Xframe.ATOMS.isfluid); % volume of the bead
VbeadXYZall = mbead./rhobeadXYZall;
VbeadXYZ = mbead./rhobeadXYZ;


% Plot
if PLOTON
    figure, hold on
    plot3D(XYZ,'bo')
    plot3D(XYZs,'ro')
    plot3D(XYZp,'go')
    view(3)
end


% interpolation grid (central grid, no images)
%nresolution = [128 128 128];
nresolution = round(128*diff(viewbox,1,2)'/max(diff(viewbox,1,2)));
xw = linspace(viewbox(1,1),viewbox(1,2),nresolution(1));
yw = linspace(viewbox(2,1),viewbox(2,2),nresolution(2));
zw = linspace(viewbox(3,1),viewbox(3,2),nresolution(3));
[Xw,Yw,Zw] = meshgrid(xw,yw,zw);
XYZgrid = [Xw(:),Yw(:),Zw(:)];

% grid neighbors (incl. images) for interpolation and discarding grid points overlapping solid
VXYZ  = buildVerletList({XYZgrid XYZall},1.2*h);  % neighbors = fluid particles
VXYZs = buildVerletList({XYZgrid XYZs},0.85*s); % neighbors = solid particles

icontactsolid = find(cellfun(@length,VXYZs)>0);
%VXYZ(icontactsolid) = repmat({[]},length(icontactsolid),1);

% interpolation on the grid of the 3D velocity (central grid)
% Do not forget even if we are applying a 2D interpretation, we use a 3D simulation
% 3D velocity are projected on 2D streamlines even if the projection of the 3rd component is 0
W = kernelSPH(h,'lucy',3); % kernel expression
v3XYZgrid = interp3SPHVerlet(XYZall,vXYZall,XYZgrid,VXYZ,W,VbeadXYZall);
vxXYZgrid = reshape(v3XYZgrid(:,1),size(Xw)); vxXYZgrid(icontactsolid) = NaN;
vyXYZgrid = reshape(v3XYZgrid(:,2),size(Xw)); vyXYZgrid(icontactsolid) = NaN;
vzXYZgrid = reshape(v3XYZgrid(:,3),size(Xw)); vzXYZgrid(icontactsolid) = NaN;
vXYZgrid  = reshape(sqrt(sum(v3XYZgrid.^2,2)),size(Xw));

% density on the grid (with a possible different h)
Wd = kernelSPH(1.08*s,'lucy',3); % kernel expression
rhobeadXYZgrid = interp3SPHVerlet(XYZall,rhobeadXYZall,XYZgrid,VXYZ,Wd,VbeadXYZall);
rhobeadXYZgrid = reshape(rhobeadXYZgrid,size(Xw)); rhobeadXYZgrid(icontactsolid) = NaN;

% Plot
if PLOTON
    figure, slice(Xw,Yw,Zw,vXYZgrid,mean(viewbox(1,:)),mean(viewbox(2,:)),mean(viewbox(3,:))), axis equal, view(2), colorbar, title(sprintf('t=%0.3f s - velocity (m/s)',tframe)), view(3)
    figure, slice(Xw,Yw,Zw,rhobeadXYZgrid,mean(viewbox(1,:)),mean(viewbox(2,:)),mean(viewbox(3,:))); axis equal, view(2), colorbar, title(sprintf('t=%0.3f s - density (kg/m3)',tframe)), view(3)
end

%% Plot pillar and sphere atoms, quiver, streamlines
figure, hold on
[xs,ys,zs] = sphere(20); [xs,ys,zs] = deal(xs*rbead,ys*rbead,zs*rbead);
colors = struct('pillar',rgb('DarkGreen'),'sphere',rgb('FireBrick'));
for i=1:size(XYZs,1)
    surf(xs+ XYZs(i,1), ys + XYZs(i,2), zs+ XYZs(i,3),'FaceColor',colors.sphere,'EdgeColor','none');
end
for i=1:size(XYZp,1)
    surf(xs+ XYZp(i,1), ys + XYZp(i,2), zs+ XYZp(i,3),'FaceColor',colors.pillar,'EdgeColor','none');
end
lighting phong, camlight left, camlight right, axis equal, view(3)

% quiver
step = 12;
boundaries = ...
    [ nearestpoint(double(xw([1,end])+viewboxsize(1)/100*[1 -1]),double(xw)) % x
      nearestpoint(double(yw([1,end])+viewboxsize(2)/100*[1 -1]),double(yw)) % y
      nearestpoint(double(zw([1,end])+viewboxsize(3)/100*[1 -1]),double(zw)) % z
                 ];
indxquiver = boundaries(1,1):step:boundaries(1,2); % x indices
indyquiver = boundaries(2,1):step:boundaries(2,2); % y indices
indzquiver = boundaries(3,1):step:boundaries(3,2); % y indices
quiver3( Xw(indyquiver,indxquiver,indzquiver),...
         Yw(indyquiver,indxquiver,indzquiver), ...
         Zw(indyquiver,indxquiver,indzquiver), ...
         vxXYZgrid(indyquiver,indxquiver,indzquiver),...
         vyXYZgrid(indyquiver,indxquiver,indzquiver),...
         vzXYZgrid(indyquiver,indxquiver,indzquiver),...
            'color',rgb('Navy'),'LineWidth',2)

% streamlines
step = 6;
boundaries = ...
    [ nearestpoint(double(xw([1,end])+viewboxsize(1)/100*[1 -1]),double(xw)) % x
      nearestpoint(double(yw([1,end])+viewboxsize(2)/100*[1 -1]),double(yw)) % y
      nearestpoint(double(zw([1,end])+viewboxsize(3)/100*[1 -1]),double(zw)) % z
                 ];
indxstreamline = boundaries(1,1):step:boundaries(1,2); % x indices
indystreamline = boundaries(2,1):step:boundaries(2,2); % y indices
indzstreamline = boundaries(3,1):step:boundaries(3,2); % y indices
[startgenX,startgenY,startgenZ] = meshgrid(double(xw(indxstreamline)),double(yw(indystreamline)),double(ztop));
vxXYZgrid_ = vxXYZgrid; vxXYZgrid_(isnan(vxXYZgrid))=0;
vyXYZgrid_ = vyXYZgrid; vyXYZgrid_(isnan(vyXYZgrid))=0;
vzXYZgrid_ = vzXYZgrid; vzXYZgrid_(isnan(vzXYZgrid))=0;
hstr = streamribbon(double(Xw),double(Yw),double(Zw),vxXYZgrid_,vyXYZgrid_,vzXYZgrid_,startgenX,startgenY,startgenZ);
set(hstr,'edgecolor','none','facecolor',rgb('DeepSkyBlue'),'facealpha',0.4)


% Plot density
% figure, hold on
[Xwcut,Ywcut,Zwcut,Rwcut] = deal(Xw,Yw,Zw,rhobeadXYZgrid);
[Xwcut2,Ywcut2,Zwcut2,Rwcut2] = deal(Xw,Yw,Zw,rhobeadXYZgrid);
zcut = 3e-4;
xcut = 3.1e-4;
Xwcut(:,:,zw>zcut) = [];
Ywcut(:,:,zw>zcut) = [];
Zwcut(:,:,zw>zcut) = [];
Rwcut(:,:,zw>zcut) = [];
Xwcut2(:,xw>xcut,:) = [];
Ywcut2(:,xw>xcut,:) = [];
Zwcut2(:,xw>xcut,:) = [];
Rwcut2(:,xw>xcut,:) = [];
isorho = 1200;
% Rwcut2(Rwcut2<=isorho)=isorho;
p1a = patch(isosurface(Xwcut2,Ywcut2,Zwcut2,Rwcut2, isorho),'FaceColor',rgb('Navy'),'EdgeColor','none');
p1b = patch(isosurface(Xwcut2,Ywcut2,Zwcut2,Rwcut2, isorho-200),'FaceColor',rgb('MediumBlue'),'EdgeColor','none');
p1c = patch(isosurface(Xwcut2,Ywcut2,Zwcut2,Rwcut2, isorho-400),'FaceColor',rgb('RoyalBlue'),'EdgeColor','none');
p1d = patch(isosurface(Xwcut2,Ywcut2,Zwcut2,Rwcut2, isorho-600),'FaceColor',rgb('DodgerBlue'),'EdgeColor','none');
p2 = patch(isocaps(Xwcut,Ywcut,Zwcut,Rwcut, 200),'FaceColor','interp','EdgeColor','none');
colormap(bone(100)), axis equal
%camlight left, camlight right, lighting gouraud, view(-138,28), axis equal
camlight left; % Adds a light to the left of the camera
camlight right; % Adds a light to the right of the camera
light('Position',[-1 -1 0.5],'Style','infinite'); % Additional light source from a specific direction
ambientLight = light('Position',[1 1 1],'Style','infinite');
set(ambientLight,'Color',[0.3 0.3 0.3]); % A soft, white ambient light
lighting phong;

view([-199 24])
camproj perspective
hfig = gcf; hax = gca;
formatfig(hfig,'color','k','InvertHardcopy',false,'position',[-2143   -123    1600    1200],'PaperPosition',[0.6350    7.0918   19.7300   15.5164])
axis off
set(hax,'color','k')
axis([0.2142    0.5488    0.1409    0.4544    0.2046    0.5135]*1e-3)

%% Assuming you have your scene set up before this script
MOVIEON = true;

if ~existsnapfile()
    set(hfig,'color','w')
    set(hax,'color','w')
    makesnap()
    set(hfig,'color','k')
    set(hax,'color','k')
end

if existmoviefile()
    MOVIEON = false;
    dispf('delete(''%s'')',fullmoviefile)
    warning('delete the movie file')
else
    set(hfig,'color','k')
    set(hax,'color','k')
end

% Number of frames for the video
nFrames = 360; % This can be adjusted for smoother animation

% Initial view settings
initialAzimuth = -199; % Adjusting for MATLAB's view system
initialElevation = 24;

% Normalize initialAzimuth to ensure smooth transition
% MATLAB's view system handles azimuths mod 360
if initialAzimuth < 0
    initialAzimuth = 360 + initialAzimuth; % Converts -199 to 161
end

% Animation parameters
azimuthEnd = initialAzimuth + 360; % Completes a full circle
elevationMin = 4; % Minimum elevation
elevationMax = 54; % Maximum elevation
midElevation = (elevationMin + elevationMax) / 2; % Midpoint for elevation
elevationAmplitude = (elevationMax - elevationMin) / 2; % Elevation change amplitude

% Time vector for sinusoidal elevation change, adjusted to start/end at initial elevation
t = linspace(0, 2*pi, nFrames);

% Pre-calculation for azimuth and elevation
azimuths = linspace(initialAzimuth, azimuthEnd, nFrames);
elevations = midElevation + elevationAmplitude * sin(t);

% Make the start and end elevations match the initial setting by adjusting the first and last values
elevations(1) = initialElevation;
elevations(end) = initialElevation;

% Animation loop
for k = 1:nFrames
    % Calculate current azimuth and elevation
    currentAzimuth = azimuths(k);
    currentElevation = elevations(k);
    
    % Ensure the azimuth is within the 0° to 360° range for viewing
    currentAzimuth = mod(currentAzimuth, 360);
    
    % Update view
    view(currentAzimuth, currentElevation);
    
    % Update the scene
    drawnow;
    
    % Optionally, capture the frame for video creation
    % frame = getframe(gcf);
    % writeVideo(videoObject, frame);
    if MOVIEON
        makemovie(hfig)
    end
end



% slice
% figure, hs= slice(Xw,Yw,Zw,sumW,single(1:3),single(1:3),single([])); set(hs,'edgecolor','none','facealpha',0.5), axis equal

% Interpretation O. Vitrac - rev. 2024-07-12-31


clearvars -except d it forcedsave PREVIOUSdumpFile dataFile

% Definitions
switch localname
    case 'WS-OLIVIER2023'
        root = 'D:\Sensory_viscosimeter_V0';
    otherwise
        error('Set your machine ''%s'' first',localname)
end
subdatafolder = '/Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary';
datafolder = fullfile(root,subdatafolder);

% POST template
allDumpFiles = {
    'dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with80SuspendedParticle_10Yparticle',
    'dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with80SuspendedParticle_1000Yparticle',
    'dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with80SuspendedParticle_100000Yparticle'
    };

jumps = 30000*30;
allTimesteps = {
    [0:jumps:10650000],
    [0:jumps:10500000],
    [0:jumps:10530000]
    };

D = 0.001;
BOX_DIMENSIONS = [0 2*D -0.1*D 1.1*D 0 2*D];
BOUNDARIES = [1 0 1]; % 1 if periodic
S = D / 48;
R = 0.5 * S; % radius of the particle (please, be very accurate)
E = 2000; % Hertz contact stiffness
A = 4 * D * D; % Area of the wall
H = 2 * R;
MU = 0.01;
NU = MU/1000;
U = 0.01;

%% choose file, backup file
if ~exist('PREVIOUSdumpFile','var'), PREVIOUSdumpFile = ''; end
if ~exist('dataFile','var'), dataFile = []; end
if ~exist('d','var'), d = 1; end
if ~exist('it','var'), it = 3; end
if ~exist('forcedsave','var'), forcedsave = false; end

% root folder
rootsaveresultfolder = fullfile(datafolder,'RESULTS_OV');
if ~exist(rootsaveresultfolder,'dir'), mkdir(rootsaveresultfolder); end

%% retrieve all frame results (if they exist)
if ischar(d) && strcmp(d,'all')
    fres = explore('*.mat',rootsaveresultfolder,3,'abbreviate');
    fresu = unique({fres.subpath},'stable');
    Elist = str2double(uncell(regexp(fresu,'\_(\d+)Yparticle','tokens')));
    nE = length(Elist);
    leg = arrayfun(@(e) sprintf('E=%s',formatsci(e,'eco')),Elist,'UniformOutput',false);
    formatfig(figure,'figname','resultsOV_meta','PaperPosition',[4.6933    9.2937   11.6133   11.1125]); %'Paperposition')
    hold on
    col = tooclear(parula(nE+1));
    hp = zeros(nE,1);
    nmax = 0;
    for i=1:nE
        k = find(ismember({fres.subpath},fresu(i)));
        nk = length(k);
        T = [];
        for j=1:nk
            tmp = load(fullfile(fres(k(j)).path,fres(k(j)).file));
            tmp.Rcurrent.E = Elist(i) * ones(height(tmp.Rcurrent),1);
            T = [T;tmp.Rcurrent]; %#ok
        end
        T = T(T.timestep>0,:);
        hp(i) = plot(T.nNodes,T.fractalDim,'o','markersize',10,'markeredgecolor',col(i,:),'markerfacecolor',col(i,:));
        nmax= max(nmax,max(T.nNodes));
    end
    n = 1:(nmax+1);
    hp(end+1) = plot(n,(n-1)./n,'k-','linewidth',1);
    uistack(hp(end),"bottom")
    formatax(gca,'fontsize',12)
    xlabel('Number of particles in the cluster')
    ylabel('Fractal dimension (-)')
    hl = legend(hp,[leg;{'linear cluster (theory)'}],'box','off','location','SouthEast');
    print_png(400,fullfile(rootsaveresultfolder,get(gcf,'filename')),'','',0,0,0)
    return
end

%% selected frame
dumpFile = allDumpFiles{d};
timesteps = allTimesteps{d};
DEBUGmode = false; % true to force intermediate plots

% results files for the selected frame
saveresultfolder = fullfile(rootsaveresultfolder,regexprep(dumpFile,'^dump\.',''));
if ~exist(saveresultfolder,'dir'), mkdir(saveresultfolder); end
saveresultfile = fullfile(saveresultfolder,sprintf('graph_it%d_T%d.mat',it,timesteps(it)));
saveresultfig2D = fullfile(saveresultfolder,sprintf('graph2D_it%d_T%d.png',it,timesteps(it)));
saveresultfig3D = fullfile(saveresultfolder,sprintf('graph3D_it%d_T%d.png',it,timesteps(it)));
if exist(saveresultfile,'file') && exist(saveresultfig2D,'file') && exist(saveresultfig3D,'file') && ~forcedsave
    warning('this iteration is discarded, set forcedsave=true or delete the file in\n %s\n\t or use\n delete(''%s'')\n delete(''%s'')\n delete(''%s'')', ...
        saveresultfolder,saveresultfile,saveresultfig2D,saveresultfig3D)
    return
end
close all
resultfigs = [figure; figure];

%% Load file
if ~strcmp(dumpFile,PREVIOUSdumpFile) || isempty(dataFile)
    dataFile = lamdumpread2(fullfile(datafolder, dumpFile), 'usesplit', [], timesteps);
    PREVIOUSdumpFile = dumpFile;
end

% Box size
coords = {'x', 'z', 'y'};
icoords = cellfun(@(c) find(ismember({'x', 'y', 'z'}, c)), coords);
box = dataFile.BOX(icoords, :); % note that the order is given by coords, here {'z'}    {'x'}    {'y'}
boxsize = diff(box, 1, 2);
PBC = [true, false, true]; % true if periodic
PBC = PBC(icoords);
PBCthickness = max(0.4 * boxsize(PBC));

%% First analysis (raw)
selection = dataFile.ATOMS(dataFile.ATOMS.TIMESTEP == timesteps(it) & dataFile.ATOMS.type >= 4, :);
XYZselection = PBCincell(selection{:, coords}, box, PBC);
[XYZimagesONLY, indXimagesONLY, copyimagesIdx] = PBCimages(XYZselection, box, PBC, PBCthickness);

if DEBUGmode
    figure, hold on, plot3D(XYZselection, 'kx'), plot3D(XYZimagesONLY, 'ro'), view(3), axis equal
end
selectionimage = selection(indXimagesONLY, :);
selectionimage{:, coords} = XYZimagesONLY;
selectionimage.type = selectionimage.type + 1000 * copyimagesIdx;
selectionwithimages = [selection; selectionimage];
selectionwithimages.isimages = selectionwithimages.type > 1000;

stypes = unique(selectionwithimages.type); 
nstypes = length(stypes);
[XYZ, stypesfull] = deal(cell(nstypes, 1));
isimages = stypes > 1000;
for i = 1:nstypes
    XYZ{i} = selectionwithimages{selectionwithimages.type == stypes(i), coords};
    stypesfull{i} = selectionwithimages.type(selectionwithimages.type == stypes(i));
end

% Control figure
if DEBUGmode
    figure, hold on, col = parula(nstypes);
    for i = 1:nstypes
        plot3D(XYZ{i}, 'o', 'color', col(i, :));
    end
    view(3), axis equal
end

%% Contact pairwise distance (based on contacts)
others = 1:nstypes;
C = repmat(struct('XYZ', [], 'i', [], 'type', NaN, 'n', NaN, 'center', [], 'jneigh', [], 'tneigh', [], 'dneigh', [], ...
    'isReunited', false, 'deleted', false, 'tobeupdated', true, 'ifull', []), nstypes, 1);
imagestoremove = [];
for i = 1:nstypes
    dispf('\n-- object %d of %d --', i, nstypes)
    j = setdiff(others, i);
    sti = stypes(i);
    stj = cat(1, stypesfull{j});
    XYZothers = cat(1, XYZ{j});
    [VXYZ, ~, ~, ~, dij] = buildVerletList({XYZ{i}, XYZothers}, 2 * H, false, 1);
    found = find(~cellfun(@isempty, VXYZ));
    currentNeigh = [VXYZ{found}];
    currenttyp = stj(currentNeigh);
    currenttypu = unique(currenttyp, 'stable')';
    currentDist = [dij{found}];
    currentDistu = arrayfun(@(t) min(currentDist(currenttyp == t)), currenttypu) / H;
    
    % Record
    C(i).i = i;
    C(i).n = size(XYZ{i}, 1);
    C(i).jneigh = j;
    C(i).type = sti;
    C(i).tneigh = currenttypu;
    C(i).jneigh = arrayfun(@(t) find(stypes == t), currenttypu);
    C(i).dneigh = currentDistu';
    C(i).XYZ = XYZ{i};
    C(i).tobeupdated = false;
end
Cbackup = C;

%% Identify split globules and reunite them
C = Cbackup;
nodes_tobeupdated = [];
for i = 1:nstypes
    dispf('object %d of %d', i, nstypes)
    if (C(i).type < 1000) ... % not an image (images of split globules are managed in the same time)
            || (~C(i).tobeupdated && ~C(i).deleted && ~C(i).isReunited) % not examined image
        [reunitedXYZ, isReunited] = PBCoutcell(XYZ{i}, box, PBC);
    else
        isReunited = false;
    end
    if isReunited
        C(i).XYZ = reunitedXYZ;
        tk = intersect(C(i).tneigh, (1:26) * 1000 + C(i).type); % for each image, we try to reunite them on the size they are
        k = arrayfun(@(t) find(stypes == t), tk);
        
        % Merge entries
        if ~isempty(k)
            XYZtmp = PBCoutcell(cat(1, C(k).XYZ), box, PBC);
            C(k(1)).XYZ = XYZtmp;
            C(k(1)).tobeupdated = true;
            [C(k(2:end)).deleted] = deal(true);
        end
        
        % Set updates
        C(i).tobeupdated = true;
        [C(C(i).jneigh).tobeupdated] = deal(true);
    elseif ~C(i).tobeupdated
        if ~C(i).deleted
            C(i).XYZ = XYZ{i};
        else
            C(i).XYZ = [];
        end
    end
    
    % Default update behavior
    if ~C(i).deleted
        C(i).n = size(C(i).XYZ, 1);
        C(i).ifull = ones(C(i).n, 1) * i;
        C(i).center = mean(C(i).XYZ, 1);
        C(i).isReunited = isReunited;
    else
        C(i).n = 0;
        C(i).center = [];
        C(i).ifull = [];
        C(i).tobeupdated = false;
    end
    
    if C(i).tobeupdated
        nodes_tobeupdated(end + 1) = i; %#ok
    end
end

%% Update the nodes
for i =  1:nstypes
    if ismember(i,nodes_tobeupdated) % to be updated
        if ~C(i).deleted
            j = setdiff(others, i);
            j = j(~[C(j).deleted]);
            XYZothers = cat(1, C(j).XYZ);
            jothers = cat(1, C(j).ifull);
            [VXYZ, ~, ~, ~, dij] = buildVerletList({C(i).XYZ, XYZothers}, 2 * H, false, 1);
            found = find(~cellfun(@isempty, VXYZ));
            currentNeigh = [VXYZ{found}];
            currentjneigh = jothers(currentNeigh);
            C(i).oldjneigh = C(i).jneigh;
            C(i).jneigh = unique(currentjneigh, 'stable')';
        end
    else
        if ~isfield(C(i),'oldjneigh') || isempty(C(i).oldjneigh)
            C(i).oldjneigh = C(i).jneigh;
        end
    end
    C(i).jneigh = C(i).jneigh(~[C(C(i).jneigh).deleted]);
end


%% Result container ----------------------------
Rtemplate = table('Size',[1 10],...
    'VariableTypes',{'string'    ,'string'  ,'double'  ,'cell','double','double'    ,'cell'    ,'double','cell'       ,'cell'}, ...
    'VariableNames',{'datafolder','dumpfile','timestep','graph' ,'nNodes','fractalDim','XYZ'   ,'counts','nodeDegrees','color'});
Rtemplate.datafolder = datafolder;
Rtemplate.dumpfile = dumpFile;
Rtemplate.timestep = timesteps(it);

%% Build the contact matrix: A
nC = length(C);
A = sparse(nC, nC);
D = sparse(nC, nC);
dmax = max(boxsize);
nmax = max([C.n]);
for i = find([C.type]<1000)
    if ~C(i).deleted
        j = C(i).jneigh;
        j = j(~[C(j).deleted]);
        if any(C(i).jneigh)
            dtmp = vecnorm(cat(1,C(j).center)-C(i).center,2,2)';
            D(i,j) = dtmp;
        else
            dtmp=0;
        end
        if ~isempty(j), j = j(dtmp<=dmax/2); end
        A(i, j) = 1;
        A(j, i) = 1; % Ensure symmetry
    end
end
% Create a table for node information
nodeInfo = table((1:nC)', 'VariableNames', {'OriginalIndex'}); % Create table with original indices
% Add additional properties to the table if needed
nodeInfo.XYZ = cell(nC, 1);
nodeInfo.Degree = zeros(nC, 1);

for i = 1:nC
    nodeInfo.XYZ{i} = C(i).XYZ;
    nodeInfo.Degree(i) = numel(C(i).jneigh); % Example: store the degree (number of neighbors)
end
% Create the graph
G = graph(A);
G.Nodes = nodeInfo;

% Display the graph's nodes table
disp(G.Nodes);


% Create a table for node information
nodeInfo = table((1:nC)', 'VariableNames', {'OriginalIndex'}); % Create table with original indices

% Add additional properties to the table if needed
nodeInfo.XYZ = cell(nC, 1);
nodeInfo.Degree = zeros(nC, 1);

for i = 1:nC
    nodeInfo.XYZ{i} = C(i).XYZ;
    nodeInfo.Degree(i) = numel(C(i).jneigh); % Example: store the degree (number of neighbors)
end

% Create the graph
G = graph(A);
G.Nodes = nodeInfo;

% Display the graph's nodes table
disp(G.Nodes);

% Plot the topology
% Identify unique subgraphs
bins = conncomp(G); % Find connected components
uniqueSubgraphs = containers.Map;
uniqueSubgraphsCounts = containers.Map;

for i = 1:max(bins)
    subG = subgraph(G, bins == i);
    sortedEdges = sortrows(table2array(subG.Edges), 1:2);
    subgraphStr = mat2str(sortedEdges);
    
    if ~isKey(uniqueSubgraphs, subgraphStr)
        uniqueSubgraphs(subgraphStr) = subG;
        uniqueSubgraphsCounts(subgraphStr) = 0;
    end
    uniqueSubgraphsCounts(subgraphStr) = uniqueSubgraphsCounts(subgraphStr) + 1;
end

% Calculate properties
subgraphProperties = [];
subgraphList = keys(uniqueSubgraphs);

for k = 1:length(subgraphList)
    subG = uniqueSubgraphs(subgraphList{k});
    nNodes = numnodes(subG);
    fractalDim = numedges(subG) / numnodes(subG);
    count = uniqueSubgraphsCounts(subgraphList{k});
    % Store node mapping
    nodeIndices = subG.Nodes.OriginalIndex; % Use the OriginalIndex from G.Nodes
    subgraphProperties = [subgraphProperties; struct('graph', subG, 'nNodes', nNodes, 'fractalDim', fractalDim, 'count', count, 'NodeMapping', nodeIndices)];
end

% Sort subgraphs by number of nodes and remove duplicates
[~, sortIdx] = sort([subgraphProperties.nNodes], 'descend');
sortedSubgraphProperties = subgraphProperties(sortIdx);

% Remove duplicates based on fractalDim and structure
uniqueSubgraphProperties = [];
uniqueKeys = containers.Map;

for i = 1:length(sortedSubgraphProperties)
    subG = sortedSubgraphProperties(i).graph;
    fractalDim = sortedSubgraphProperties(i).fractalDim;
    nNodes = sortedSubgraphProperties(i).nNodes;
    uniqueKey = sprintf('%.2f-%d', fractalDim, nNodes); % Unique key based on fractal dimension and number of nodes
    
    if ~isKey(uniqueKeys, uniqueKey)
        uniqueKeys(uniqueKey) = true;
        uniqueSubgraphProperties = [uniqueSubgraphProperties; sortedSubgraphProperties(i)];
    end
end

% Plot unique subgraphs
figure(resultfigs(1))
formatfig(resultfigs(1),'figname',lastdir(saveresultfig2D),'PaperPosition',[-0.3939    3.6647   21.7719   22.393]);
clf(resultfigs(1))
nUnique = length(uniqueSubgraphProperties);
nCols = floor(sqrt(nUnique));
nRows = ceil(nUnique / nCols);
Rcurrent = repmat(Rtemplate,nUnique,1);

% Choose color
cmap = colormap(jet);
normDegree = @(nodeDegrees) (nodeDegrees - min(nodeDegrees)) / (max(nodeDegrees) - min(nodeDegrees)); % Normalize degree
colorDegree = @(nodeDegrees) interp1(linspace(0, 1, size(cmap, 1)), cmap, normDegree(nodeDegrees));

% for each unique case
for idx = 1:nUnique
    subGData = uniqueSubgraphProperties(idx);
    subGData.NodeDetails = G.Nodes(subGData.NodeMapping,:);
    subplot(nRows, nCols, idx);
    
    % Get node degrees
    nodeDegrees = degree(subGData.graph);
    
    % Plot the graph with nodes colored according to their degrees
    Nodelabel = cell(subGData.nNodes,1);
    if DEBUGmode
        for inl = 1:subGData.nNodes
            Nodelabel{inl} = sprintf('\\bf%d\\rm: %d-%d-%d-%d',subGData.graph.Nodes.OriginalIndex(inl), ...
                C(subGData.graph.Nodes.OriginalIndex(inl)).n,...
                C(subGData.graph.Nodes.OriginalIndex(inl)).deleted,...
                C(subGData.graph.Nodes.OriginalIndex(inl)).isReunited,...
                C(subGData.graph.Nodes.OriginalIndex(inl)).tobeupdated);
        end
    else
        Nodelabel = {};
    end

    p = plot(subGData.graph, 'Layout', 'force', 'NodeLabel', Nodelabel);
    p.NodeCData = nodeDegrees;
    
    % Adjust colorbar
    colormap(jet)
    cb = colorbar('eastoutside');
    cb.Label.String = 'Node Degree';
    pos = cb.Position;
    cb.Position = [pos(1) + 4*pos(3), pos(2) + 0.25 * pos(4), 0.25 * pos(3), 0.5 * pos(4)];
    
    % Set color limits ensuring valid range
    if max(nodeDegrees) > 1
        clim([1, max(nodeDegrees)]);
    else
        clim([1, 2]); % Set a default valid range if max degree is 1
    end

    title(sprintf('Nodes: %d, Fractal Dim: %.2f, Count: %d', subGData.nNodes, subGData.fractalDim, subGData.count));

    % store results
    Rcurrent.graph{idx} = subGData.graph;
    Rcurrent.nNodes(idx) = subGData.nNodes;
    Rcurrent.fractalDim(idx) = subGData.fractalDim;
    Rcurrent.count(idx) = subGData.count;
    Rcurrent.nodeDegrees{idx} = nodeDegrees;
    Rcurrent.XYZ{idx} = subGData.NodeDetails.XYZ;
    Rcurrent.color{idx} = colorDegree(nodeDegrees);

end

% global title
sgtitle(sprintf('Time Step: %d',timesteps(it)))

% Save results and print figure
save(saveresultfile,'Rcurrent')
print_png(400,fullfile(saveresultfolder,get(resultfigs(1),'filename')),'','',0,0,0)



%% Identify unique subgraphs
% bins = conncomp(G); % Find connected components
% uniqueSubgraphs = containers.Map;
% uniqueSubgraphsCounts = containers.Map;
% 
% for i = 1:max(bins)
%     subG = subgraph(G, bins == i);
%     sortedEdges = sortrows(table2array(subG.Edges), 1:2);
%     subgraphStr = mat2str(sortedEdges);
% 
%     if ~isKey(uniqueSubgraphs, subgraphStr)
%         uniqueSubgraphs(subgraphStr) = subG;
%         uniqueSubgraphsCounts(subgraphStr) = 0;
%     end
%     uniqueSubgraphsCounts(subgraphStr) = uniqueSubgraphsCounts(subgraphStr) + 1;
% end
% 
% %%Calculate properties
% subgraphProperties = [];
% subgraphList = keys(uniqueSubgraphs);
% 
% for k = 1:length(subgraphList)
%     subG = uniqueSubgraphs(subgraphList{k});
%     nNodes = numnodes(subG);
%     fractalDim = numedges(subG) / numnodes(subG);
%     count = uniqueSubgraphsCounts(subgraphList{k});
% 
%     % Store node mapping
%     nodeIndices = subG.Nodes.OriginalIndex; % Use the OriginalIndex from G.Nodes
%     subgraphProperties = [subgraphProperties; struct('graph', subG, 'nNodes', nNodes, 'fractalDim', fractalDim, 'count', count, 'NodeMapping', nodeIndices)];
% end

% Filter subgraphs with fractal dimension >= 1
filteredSubgraphProperties = subgraphProperties([subgraphProperties.fractalDim] > 0.6);

% Plot filtered subgraphs in 3D
figure(resultfigs(2))
formatfig(resultfigs(2),'figname',lastdir(saveresultfig3D),'PaperPosition',[-0.0000    0.3500   21.0000   29.0000]);
clf(resultfigs(2))
nFiltered = length(filteredSubgraphProperties);
nCols = floor(sqrt(nFiltered));
nRows = ceil(nFiltered / nCols);

for idx = 1:nFiltered
    subGData = filteredSubgraphProperties(idx);
    subplot(nRows, nCols, idx);
    
    % Get node degrees
    nodeDegrees = subGData.graph.Nodes.Degree;
    
    % Plot each globule in the subgraph
    hold on;
    for j = 1:numel(subGData.NodeMapping)
        nodeIdx = subGData.NodeMapping(j);
        if nodeIdx > 0 % Ensure valid index
            globuleXYZ = G.Nodes.XYZ{nodeIdx};
            globuleDegree = nodeDegrees(j);
            
            % Map degree to color
            cmap = colormap(jet);
            clim([1 max(nodeDegrees)]);
            normDegree = (globuleDegree - min(nodeDegrees)) / (max(nodeDegrees) - min(nodeDegrees)); % Normalize degree
            color = interp1(linspace(0, 1, size(cmap, 1)), cmap, normDegree);
            
            % Plot the 3D scatter plot for the globule
            if ~isempty(globuleXYZ)
                scatter3(globuleXYZ(:, 1), globuleXYZ(:, 2), globuleXYZ(:, 3), 36, repmat(color, size(globuleXYZ, 1), 1), 'filled');
            end
        end
    end
    hold off;
    
    % Add colorbar and set limits
    cb = colorbar('eastoutside');
    cb.Label.String = 'Node Degree';
    pos = cb.Position;
    cb.Position = [pos(1) + 5*pos(3), pos(2) + 0.25 * pos(4), pos(3) * 0.25, pos(4) * 0.5];
    
    % Set color limits ensuring valid range
    if max(nodeDegrees) > 1
        clim([1, max(nodeDegrees)]);
    else
        clim([1, 2]); % Set a default valid range if max degree is 1
    end
    axis equal, axis tight, view(3)

    % Title for the plot
    title(sprintf('Nodes: %d, Fractal Dim: %.2f, Count: %d', subGData.nNodes, subGData.fractalDim, subGData.count));

end
% global title
sgtitle(sprintf('Time Step: %d',timesteps(it)))


% Save results and print figure
print_png(400,fullfile(saveresultfolder,get(resultfigs(2),'filename')),'','',0,0,0)

% My old code
% % Interpretation O. Vitrac - rev. 2024-07-12
% 
% % Definitions
% switch localname
%     case 'WS-OLIVIER2023'
%         root = 'D:\Sensory_viscosimeter_V0';
%     otherwise
%         error('Set your machine ''%s'' first',localname)
% end
% subdatafolder = '/Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary';
% datafolder = fullfile(root,subdatafolder);
% 
% % POST template
% allDumpFiles = {
%     %'dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with40SuspendedParticle_10Yparticle',
%     %'dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with40SuspendedParticle_1000Yparticle',
%     %'dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with40SuspendedParticle_100000Yparticle',
%     'dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with80SuspendedParticle_10Yparticle',
%     'dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with80SuspendedParticle_1000Yparticle',
%     'dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with80SuspendedParticle_100000Yparticle'
%     };
% 
% jumps = 30000*30;
% allTimesteps = {
%     %[0:jumps:10080000],
%     %[0:jumps:9990000],
%     %[0:jumps:10170000],
%     [0:jumps:10650000],
%     [0:jumps:10500000],
%     [0:jumps:10530000]
%     };
% 
% D = 0.001;
% BOX_DIMENSIONS = [0 2*D -0.1*D 1.1*D 0 2*D];
% BOUNDARIES = [1 0 1]; % 1 if periodic
% S = D / 48;
% R = 0.5 * S; % radius of the particle (please, be very accurate)
% E = 2000; % Hertz contact stiffness
% A = 4 * D * D; % Area of the wall
% H = 2 * R;
% MU = 0.01;
% NU = MU/1000;
% U= 0.01;
% 
% % load file
% d = 1;
% dumpFile = allDumpFiles{d};
% timesteps = allTimesteps{d};
% dataFile=lamdumpread2(fullfile(datafolder,dumpFile),'usesplit',[], timesteps);
% 
% % box size
% coords = {'x','y','z'};
% icoords = cellfun(@(c) find(ismember({'x','y','z'},c)),coords);
% box = dataFile.BOX(icoords,:); % note that the order is given by coords, here {'z'}    {'x'}    {'y'}
% boxsize = diff(box,1,2);
% PBC = [true,false,true]; % true if periodic
% PBCthickness = max(0.4*boxsize(PBC));
% 
% %% First analysis (raw)
% it = 3;
% selection = dataFile.ATOMS(dataFile.ATOMS.TIMESTEP==timesteps(it) & dataFile.ATOMS.type>=4,:);
% XYZselection = PBCincell(selection{:,coords},box,PBC);
% [XYZimagesONLY ,indXimagesONLY,copyimagesIdx]= PBCimages(XYZselection,box,PBC,PBCthickness);
% figure, hold on, plot3D(XYZselection,'kx'), plot3D(XYZimagesONLY,'ro'), view(3), axis equal
% selectionimage = selection(indXimagesONLY,:);
% selectionimage{:,coords} = XYZimagesONLY;
% selectionimage.type = selectionimage.type+1000*copyimagesIdx;
% selectionwithimages = [selection;selectionimage];
% selectionwithimages.isimages = selectionwithimages.type>1000;
% 
% stypes = unique(selectionwithimages.type); nstypes = length(stypes);
% [XYZ,stypesfull] = deal(cell(nstypes,1));
% isimages = stypes>1000;
% for i = 1:nstypes
%     XYZ{i} = selectionwithimages{selectionwithimages.type == stypes(i),coords};
%     stypesfull{i} = selectionwithimages.type(selectionwithimages.type == stypes(i));
% end
% % control figure
% figure, hold on, col = parula(nstypes); for i=1:nstypes, plot3D(XYZ{i},'o','color',col(i,:)), end, view(3), axis equal
% 
% 
% %% Contact pair wise distance (based on contacts)
% % i = 45, j = 125
% others = 1:nstypes;
% C = repmat(struct('XYZ',[],'i',[],'type',NaN,'n',NaN,'center',[],'jneigh',[],'tneigh',[],'dneigh',[],...
%     'isReunited',false,'deleted',false,'tobeupdated',true,'ifull',[]),nstypes,1);
% imagestoremove = [];
% for i=1:nstypes
%     dispf('\n-- object %d of %d --',i,nstypes)
%     j = setdiff(others,i);
%     sti = stypes(i);
%     stj = cat(1,stypesfull{j});
%     XYZothers = cat(1,XYZ{j});
%     [VXYZ,~,~,~,dij]  = buildVerletList({XYZ{i} XYZothers},2*H,false,1);
%     found = find(~cellfun(@isempty,VXYZ));
%     currentNeigh = [VXYZ{found}];
%     currenttyp = stj(currentNeigh);
%     currenttypu = unique(currenttyp,'stable')';
%     currentDist = [dij{found}];
%     currentDistu = arrayfun(@(t) min(currentDist(currenttyp==t)),currenttypu)/H;
%     % record
%     C(i).i = i;
%     C(i).n = size(XYZ{i},1);
%     C(i).jneigh = j;
%     C(i).type = sti;
%     C(i).tneigh = currenttypu;
%     C(i).jneigh = arrayfun(@(t) find(stypes==t), currenttypu);
%     C(i).dneigh = currentDistu';
%     C(i).XYZ = XYZ{i};
%     C(i).tobeupdated = false;
% end
% Cbackup = C;
% 
% %% Identify split globules and reunite them
% C = Cbackup;
% nodes_tobeupdated = [];
% for i=1:nstypes
%     dispf('object %d of %d',i,nstypes)
%     if C(i).type<1000
%         [reunitedXYZ, isReunited] = PBCoutcell(XYZ{i}, box, PBC);
%     else
%         isReunited = false;
%     end
%     if isReunited
%         C(i).XYZ = reunitedXYZ;
%         tk = intersect(C(i).tneigh,(1:26)*1000+C(i).type); % for each image, we try to reunite them on the size they are
%         k = arrayfun(@(t)find(stypes==t),tk);
%         % merge entries
%         XYZtmp = PBCoutcell(cat(1,C(k).XYZ),box,PBC);
%         C(k(1)).XYZ = XYZtmp;
%         C(k(1)).tobeupdated = true;
%         [C(k(2:end)).deleted] = deal(true);
%         % set updates
%         C(i).tobeupdated = true;
%         [C(C(i).jneigh).tobeupdated] = deal(true);
%     else
%         if ~C(i).deleted
%             C(i).XYZ = XYZ{i};
%         else
%             C(i).XYZ = [];
%         end
%     end
%     % default update behavior
%     if ~C(i).deleted
%         C(i).n = size(C(i).XYZ,1);
%         C(i).ifull = ones(C(i).n,1)*i;
%         C(i).center = mean(C(i).XYZ,1);
%         C(i).isReunited = isReunited;
%     else
%         C(i).n = [];
%         C(i).center = [];
%         C(i).ifull = [];
%         C(i).tobeupdated = false;
%     end
%     if C(i).tobeupdated
%         nodes_tobeupdated(end+1) = i; %#ok
%     end
% end
% 
% %% Update the nodes
% for i = nodes_tobeupdated
%     j = setdiff(others,i);
%     XYZothers = cat(1,C(j).XYZ);
%     jothers = cat(1,C(j).ifull);
%     [VXYZ,~,~,~,dij]  = buildVerletList({C(i).XYZ XYZothers},2*H,false,1);
%     found = find(~cellfun(@isempty,VXYZ));
%     currentNeigh = [VXYZ{found}];
%     currentjneigh = jothers(currentNeigh);
%     C(i).oldjneigh = C(i).jneigh;
%     C(i).jneigh = unique(currentjneigh,'stable')';
% end
% 
% %% Build the contact matrix: A
% nC = length(C);
% A = zeros(nC,nC);
% for i=1:length(C)
%     A(i,C(i).jneigh) = 1;
%     A(C(i).jneigh,i) = 1;
% end
% G = graph(A);
% 

% KE_t for post-treatment of Billy' dump files (3D viscosimeter)
% INRAE\Olivier Vitrac - rev. 2023-03-26
% INRAE\William Jenkinson

% Dependencies (not included in MS, at least not yet)
%   lamdumpread2()    version 2023-03-23 or later
%   buildVerletList() version 2023-03-25 or later
%
% note: be sure Olivier/INRA/Codes/MS is in your Path (MS=Molecular Studio)

% Revision history
% 2023-03-23 RC, early design based on dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_Hertzdiv100_lite
% 2023-03-24 first interaction with Billy
%            the file for design was shifted to dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_Hertzdiv10_lite
% 2023-03-25 implementation of a full Verletlist, automatic identification of fluid-solid contacts without using any
%            particular topology, the template is fully operational and used to plot the number of contacts with time
% 2023-03-06 first implementation of Hertz contacts (to be validated and extended)
%            better figure management (previous results can be reloaded)
% 2023-03-29 [BRANCH - WJ] script taken to template the kinetic energy vs time
% 2023-03-31 WJ - meta data and script are up-to-date for the calculation of Kinetic Energy

%% read datafile

% path definitions (please add your machine name by typing localname in your command window)
switch localname
    case 'LP-OLIVIER2022'
        local = 'C:\Users\olivi\OneDrive - agroparistech.fr\Billy\ProductionSandbox_toOV_23-03-2023';
    case 'LX-Willy2021'
        local = '/Data/billy/Results/Viscosimeter_SMJ_V6/ProductionSandbox_toOV_23-03-2023';
    case 'YOUR MACHINE'
        local = 'it is the path where the dump file is located, results are stored at the sample place';
    otherwise
        error('add a case with your machine name, which is ''%s''',localname)
end
datafile = 'dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_Hertzdiv100_lite';
%datafile = 'dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1';
fulldatafile = fullfile(local,datafile); % concatenate path (local) and data filename
X = lamdumpread2(fulldatafile); % be sure the last version of lamdumpread2() is in the same folder as this script

% result file (to store results)
resultfile = fullfile(local,['RESULT_' datafile '.mat']);

%% Region-based definitions:  Wall and fluid regions
% note that the interface between regions is defined from pair-distances
types = struct('wall',1,'fluid',2);
X.ATOMS.iswall = X.ATOMS.type==types.wall;  % add the column iswall to the table X.ATOMS
X.ATOMS.isfluid = X.ATOMS.type==types.fluid;% add the column isfluid to the table X.ATOMS
X.ATOMS.isundef = ~X.ATOMS.iswall & ~X.ATOMS.isfluid; % add the column isundef to the table X.ATOMS

%% Control frame
% note that the data are stored in data.ATOMS, which is a table with named colums allowing hybrid indexing
nsteps = length(X.TIMESTEP);
icurrenttime = ceil(0.5*nsteps); % index of the control frame (used to set basic definitions before more advanced interpretation)
currenttime = X.TIMESTEP(icurrenttime);
rawframe = X.ATOMS(X.ATOMS.TIMESTEP==currenttime,{'id','type','x','y','z','iswall','isfluid','isundef'});
frame = table2array(rawframe(:,{'x','y','z'})); % generate an array of coordinates

% Build the main Verlet list (for all particles)
% V use the natural indexing instead of rawframe.id
cutoff = 60e-6; % empty or NaN value will force an automatic estimation of cutoff
[V,cutoff,dmin] = buildVerletList(frame,cutoff); % cutoff can be omitted
 
% Build the secondary Verlet lists (highly vectorized code)
% V1 the neighbors of type 2 (fluid) for type 1 atoms (1..n1)
% V2 the neighbors of type 1 (wall) for type 2 atoms (1..n2)
idx1 = find(rawframe.type==1); n1 = length(idx1); % indices of the wall particles in the current frame
idx2 = find(rawframe.type==2); n2 = length(idx2); % indices of the fluid particles in the current frame
V1 = cellfun(@(v) v(rawframe.type(v)==2),V(idx1),'UniformOutput',false); % Verlet list for type 1 in contact with type 2
V2 = cellfun(@(v) v(rawframe.type(v)==1),V(idx2),'UniformOutput',false); % Verlet list for type 1 in contact with type 2
% corresponding distances d1,d2
% some distances can be empty for d2
d1 = arrayfun(@(i) pdist2(frame(idx1(i),:),frame(V1{i},:)),(1:n1)','UniformOutput',false); % evaluate the distance for each idx1(i)
d2 = arrayfun(@(i) pdist2(frame(idx2(i),:),frame(V2{i},:)),(1:n2)','UniformOutput',false); % evaluate the distance for each idx2(i)
d1min = cellfun(@min,d1); % minimum distance for each idx1()
d2min = cellfun(@min,d2,'UniformOutput',false); % minimum distance for each idx2()
[d2min{cellfun(@isempty,d2)}] = deal(NaN); % populate empty distances with NaN
d2min = cat(1,d2min{:}); % we collect all now all distances (since the fluid is moving with respect with the wall)
 
% Identify beads of type 1 (wall) directly in contact with fluids
% this method is general and relies only on pair distances
% the term "contact" is general (vincinity) not a "real" contact as set later
iswallcontact = d1min < 1.5 * dmin;  % condition for a wall particle to be considered possibly in contact with the fluid
isfluidcontact = ~isnan(d2min);      % the condition is less restrictive for the fluid, based on the cutoff distance
V1contact = V1(iswallcontact);       % "contact" Verlet list corresponding to V1
V2contact = V2(isfluidcontact);      % "contact" Verlet list corresponding to V1
iwallcontact = idx1(iswallcontact);
ifluidcontact = unique(cat(2,V1contact{:})); % within cutoff
% 
% control plot
% one color is assigned to each phase
% symbols are filled if they are included in the contact Verlet list
% type figure, rgb() to list all available colors
colors = struct('wall',rgb('Crimson'),'fluid',rgb('DeepSkyBlue'),'none','None');
figure, hold on
plot3D(frame(rawframe.isundef,:),'ko');
plot3D(frame(rawframe.iswall,:),'o','MarkerEdgeColor',colors.wall,'MarkerFaceColor',colors.none);
plot3D(frame(iwallcontact,:),'o','MarkerEdgeColor',colors.none,'MarkerFaceColor',colors.wall);
plot3D(frame(rawframe.isfluid,:),'o','MarkerEdgeColor',colors.fluid,'MarkerFaceColor',colors.none);
plot3D(frame(ifluidcontact,:),'o','MarkerEdgeColor',colors.none,'MarkerFaceColor',colors.fluid);
axis equal, axis tight, view(3)

%% [1:X] INTERPRETATION: counting the number of contact with time
% count the number of fluid beads in contact with wall (within 2*R)
R = 0.5*0.001/48; % radius of the particle (please, be very accurate)
dbond = 2*R; % bond = link between 2 atoms
wall_id  = rawframe.id(iwallcontact);   % extract the ids matching the contact condition in the reference frame
fluid_id = rawframe.id(ifluidcontact);  % idem for the fluid particles within the contact Verlet list
% config setup
E = 2e4 ; % ref:2e6, Hertzdiv10:2e5, Hertzdiv100:2e4
Hertzconfig = struct('name',{'wall','fluid'},'R',R,'E',E); % entries are duplicated if not mentioned

% prepare to calculate pair distances between different beads
pairdist = @(X,Y) triu(pdist2(X,Y),0); % note that the diagonal is included here (since X and Y are different)
ncontacts = zeros(nsteps,1);
KEnergy = zeros(nsteps,1);
[t_,t__] = deal(clock); %#ok<*CLOCK> 
screen = '';
for icurrenttime = 1:nsteps
    currenttime = X.TIMESTEP(icurrenttime);
    % --- some display, to encourage the user to be patient
    if mod(icurrenttime,5)
        if etime(clock,t__)>2 %#ok<*DETIM>
            t__ = clock; dt = etime(t__,t_); done = 100*(icurrenttime-1)/nsteps;
            screen = dispb(screen,'[%d/%d] interpretation [ done %0.3g %% | elapsed %0.3g s | remaining %0.3g s ] ...', ...
                icurrenttime,nsteps,done,dt,dt*(100/done-1));
        end
    end % --- end of display
    Vel = table2array(X.ATOMS((X.ATOMS.TIMESTEP==currenttime) & (X.ATOMS.type==1),{'vx','vy','vz','mass'})); % raw data for the current frame
    V_mag_sq = Vel(:,1).^2 + Vel(:,2).^2 + Vel(:,3).^2;
    KEnergy(icurrenttime) = sum(0.5*Vel(:,4).*V_mag_sq); % sum forces along x
end

% save the data to enable a refresh of the figure without restarting this block
timesteps = X.TIMESTEP;
save(resultfile,'datafile','KEnergy','ncontacts','timesteps','Hertzconfig')
dispf('Results saved (%s):',datafile), fileinfo(resultfile)

%% PLots and figure management

% reload the data
if exist(resultfile,'file'), load(resultfile), end

% plot number of contacts vs. time
contactfigure = figure;
formatfig(contactfigure,'figname',['NumberContact' datafile],'PaperPosition',[1.5000    9.2937   18.0000   11.1125])
plot(timesteps,ncontacts,'linewidth',0.5,'Color',rgb('Crimson'))
formatax(gca,'fontsize',14)
xlabel('time (units)','fontsize',16)
ylabel('Kinetic energy of particles ()','fontsize',16)
wtitle = textwrap({'\bfdump file:\rm';datafile},40);
title(regexprep(wtitle,'_','\\_'),'fontsize',10)

% plot number of Hertz projection along x vs. time
hertzfigure = figure;
formatfig(hertzfigure,'figname',['KineticEnergy' datafile],'PaperPosition',[1.5000    9.2937   18.0000   11.1125])
plot(timesteps,KEnergy,'linewidth',0.5,'Color',rgb('Teal'))
formatax(gca,'fontsize',14)
xlabel('Frame (-)','fontsize',16)
ylabel('Kinetic energy (J)','fontsize',16)
wtitle = textwrap({'\bfdump file:\rm';datafile},40);
title(regexprep(wtitle,'_','\\_'),'fontsize',10)

% save images in all valid formats (including Matlab one, the data can be extracted with this format)
% filenames are identical to the dump file with the proper extension: fig, pdf, png
for myfig = [contactfigure,hertzfigure] % loop over all figures to print
    figure(myfig)
    saveas(gcf,fullfile(local,[get(gcf,'filename') '.fig']),'fig') % fig can be open without restarting the code
    print_pdf(600,[get(gcf,'filename') '.pdf'],local,'nocheck') % PDF 600 dpi
    print_png(600,[get(gcf,'filename') '.png'],local,'',0,0,0)  % PNG 600 dpi
end

function x = MDunidrnd(n,m)
%  MDUNIDRND generates m uniform random numbers (one appearance) ranged between 1 and n (n>m)
%
% 	Syntax:  x = MDunidrnd(n,m)
       
% MDsimple 2.0 - 21/07/03 - Olivier Vitrac - rev.

% argument check
if n'n), end

% random generator
x = []; lx = 0;
while lxend+1:m) = unidrnd(n,m-lx,1);
	[xu,j] = unique(x);
	x = x(sort(j));
	lx = length(x);
end

function [Vp,Xout,Yout,Zout] = PBCgrid(varargin)
%PBCgrid add periodic boundary conditions to meshgrid/ndgrid meshed values
%
%   USAGE in 3D
%       [Vp,Xp,Yp,Zp] = PBCgrid(X,Y,Z,V,PBC [,cutoff])
%   USAGE in 2D
%       [Vp,Xp,Yp] = PBCgrid(X,Y,V,PBC [,cutoff])
%   USAGE in 1D
%       [Vp,Xp] = PBCgrid(X,V,PBC [,cutoff])
%
%   INPUTS (3D):
%            X: a x b x c array created by meshgrid, ndgrid coding for X coordinates
%            Y: a x b x c array created by meshgrid, ndgrid coding for Y coordinates
%            Z: a x b x c array created by meshgrid, ndgrid coding for Z coordinates
%            V: a x b x c array where V(i,j,k) is the value at X(i,j,k), Y(i,j,k) and Z(i,j,k)
%          PBC: 3 x 1 boolean array (true if the dimension is periodic)
%       cutoff: cutoff value either scalar or vector
%               [cutoff;cutoff;cutoff] or [cutoffx;cutoffy;cutoffz]
%
%   INPUTS (2D):
%            X: a x b array created by meshgrid, ndgrid coding for X coordinates
%            Y: a x b array created by meshgrid, ndgrid coding for Y coordinates
%            V: a x b array where V(i,j) is the value at X(i,j) and Y(i,j)
%          PBC: 2 x 1 boolean array (true if the dimension is periodic)
%       cutoff: cutoff value either scalar or vector
%               [cutoff;cutoff] or [cutoffx;cutoffy]
%
%   INPUTS (1D):
%            X: a x 1 array created by linspace or equivalent
%            V: a x 1 array where V(i) is the value at X(i)
%          PBC: boolean (true if the dimension is periodic)
%       cutoff: cutoff value
%
%   OUTPUTS (1-3D)
%           Vp: array with ndims(Vp) = ndims(V) augmented with perodic values
%           Xp,Yp,Zp corresponding coordinates
%
%
%
%   See also: PBCgridshift, PBCimages, PBCimageschift, PBCincell
%
%
%
% Example:
%      [X,Y,V] = peaks(100);
%      [Vp,Xp,Yp] = PBCgrid(X,Y,V,[true,true],[1.5 3]);
%      figure, mesh(Xp,Yp,Vp)


% MS 3.0 | 2024-03-15 | INRAE\han.chen@inrae.fr, INRAE\Olivier.vitrac@agroparistech.fr | rev. 2024-03-16


% Revision history
% 2024-03-15 release candidate with example
% 2024-03-16 fix nmirror when more than available points are required


%% check arguments
if nargin<3, error('Syntax: [Vp,Xp,Yp,Zp] = PBCgrid(X,Y,Z,V,PBC [,cutoff]) in 3D (other syntaxes available)'), end
X = varargin{1};
d = ndims(X); %<<- the number of dimensions in X sets 1D, 2D or 3D syntax
if d==3 && nargin<5, error('five arguments are at least required in 3D:  [Vp,Xp,Yp,Zp] = PBCgrid(X,Y,Z,V,PBC [,cutoff])'), end
if d==2 && nargin<4, error('four arguments are at least required in 2D:  [Vp,Xp,Yp] = PBCgrid(X,Y,V,PBC [,cutoff])'), end
if d>1
    Y = varargin{2};
    if ~isequal(size(X),size(Y)), error('X and Y are not compatible'), end
    if d>2 % 3D
        Z = varargin{3};
        if ~isequal(size(X),size(Z)), error('X, Y and Z are not compatible'), end
        V = varargin{4};
        if ~isequal(size(X),size(V)), error('V is not compatible with supplied X, Y and Z'), end
        PBC = varargin{5};
        if nargin>5, cutoff = varargin{6}; else cutoff = []; end %#ok<*SEPEX>
    else % 2D
        V = varargin{3};
        if ~isequal(size(X),size(V)), error('V is not compatible with supplied X and Y'), end
        PBC = varargin{4};
        if nargin>4, cutoff = varargin{5}; else cutoff = []; end
    end
else % 1D
    V = varargin{2};
    if ~isequal(size(X),size(V)), error('V is not compatible with supplied X'), end
    PBC = varargin{3};
    if nargin>3, cutoff = varargin{4}; else cutoff = []; end
end
% fix PBC
if length(PBC)~=d, error('PBC should be a %dx1 boolean array',d), end
PBC = PBC>0; % convert to boolean
% fix cutoff (heuristic for the default value)
if isempty(cutoff), cutoff = max(abs(X(1:2,1:2,1)-X(1,1,1)),[],'all')*(numel(X).^(1/d))/4; end
if length(cutoff)==1, cutoff = cutoff(ones(d,1)); end
cutoff(~PBC) = 0;
% discriminat between meshgrid or ndgrid generation
if d>1
    ismeshgrid =  all(diff(X(1:2,:,:),1,1)==0); % true if X,Y,Z generated with meshgrid
else
    ismeshgrid = false; % by convention
    X = X(:); % force column-wise
    V = V(:); % force column-wise
end
% Found bounds along X and Y (dependent on meshgrid or ndgrid generation)
nmirror = zeros(d,1); % number of values to mirror along each dimension
if ismeshgrid % 2D or 3D
    % bounds
    xmin = min(X(1,:,1));
    xmax = max(X(1,:,1));
    ymin = min(Y(:,1,1));
    ymax = max(Y(:,1,1));
    if cutoff(1)>0
        ntmp = find(abs(X(1,:,1)-X(1,1,1))>cutoff(1),1,'first')-1;
        if isempty(ntmp), nmirror(1) = size(X,2); else, nmirror(1) = ntmp; end
    end
    if cutoff(2)>0
        ntmp = find(abs(Y(:,1,1)-Y(1,1,1))>cutoff(2),1,'first')-1;
        if isempty(ntmp), nmirror(2) = size(X,1); else, nmirror(2) = ntmp; end
    end
    dx = diff(X(1,:,1),1,2);
    dy = diff(Y(:,1,1),1,1);
else % ndgrid: 1D, 2D or 3D
    xmin = min(X(:,1,:));
    xmax = max(X(:,1,:));
    if cutoff(1)>0
        ntmp = find(abs(X(:,1,1)-X(1,1,1))>cutoff(1),1,'first')-1;
        if isempty(ntmp), nmirror(1) = size(X,1); else, nmirror(1) = ntmp; end
    end
    dx = diff(X(:,1,1),1,1);
    if d>1
        ymin = min(Y(1,:,1));
        ymax = max(Y(1,:,1));
        if cutoff(2)>0
            ntmp = find(abs(Y(1,:,1)-Y(1,1,1))>cutoff(2),1,'first')-1;
            if isempty(ntmp), nmirror(2) = size(X,2); else, nmirror(2) = ntmp; end
        end
        dy = diff(X(1,:,1),1,2);
    else
        [ymin,ymax] = deal(NaN);
    end
end
% Found bounds along Z. Note that it is managed independently of ndgrid, meshgrid
if d>2 %3D
    zmin = min(Z(:,:,1));
    zmax = max(Z(:,:,1));
    if cutoff(3)>0
        ntmp = find(abs(Z(:,:,1)-Z(1,1,1))>cutoff(3),1,'first')-1;
        if isempty(ntmp), nmirror(3) = size(X,3); else, nmirror(3) = ntmp; end
    end
    dz = diff(X(1,1,:),1,3);
else
    [zmin,zmax] = deal(NaN);
end
% full bounds
bounds = [xmin xmax; ymin ymax; zmin zmax]; % NaN values for non-defined dimensions
dimensions = diff(bounds,1,2);

%% apply PBC to V
% nmirror(1) -> number of points to translate along X (regardless the value of ismeshgrid)
% nmirror(2) -> number of points to translate along Y (idem)
% nmirror(3) -> number of points to translate along Z (idem)
% dimensions
% a = length of grid along Y (if ismeshgrid), along X instead (ndgrid)
% b = length of grid along X (if ismeshgrid), along Y instead (ndgrid)
% c = length of grid along Z
[a,b,c] = size(X);
if ismeshgrid % 2D, 3D
    left = (b-nmirror(1)+1):b;
    right = 1:nmirror(1);
    indx = [left, 1:b, right];
    top = (a-nmirror(2)+1):a;
    bottom = 1:nmirror(2);
    indy = [top, 1:a, bottom];
else % 1D, 2D, 3D
    left = (a-nmirror(1)+1):a;
    right = 1:nmirror(1);
    indx = [left, 1:a, right];
    if d>1
        top = (b-nmirror(2)+1):b;
        bottom = 1:nmirror(2);
        indy = [top, 1:b, bottom];
    end
end
if d>2
    front = (c-nmirror(3)+1):c;
    back = 1:nmirror(3);
    indz = [front, 1:c, back];
end


%% duplication and translation
% (note that dimensions and nmirror obey to the same convention independently of ismeshgrid)
% nmirror(1) and dimensions(1) are always along X, 2 for Y and 3 for Z
if ismeshgrid % 2D and 3D
    if d==2
        Vp = V(indy,indx);
        Xp = X(indy,indx);
        Yp = Y(indy,indx);
    else
        Vp = V(indy,indx,indz);
        Xp = X(indy,indx,indz);
        Yp = Y(indy,indx,indz);
        Zp = Y(indy,indx,indz);
    end
    % translation X and Y (Z common with ndgrid)
    Xp(:,1:nmirror(1),:) = Xp(:,1:nmirror(1),:)-dimensions(1)-dx(end); % left translation
    Xp(:,(end-nmirror(1)+1):end,:) = Xp(:,(end-nmirror(1)+1):end,:)+dimensions(1)+dx(1); % right translation
    Yp(1:nmirror(2),:,:) = Yp(1:nmirror(2),:)-dimensions(2)-dy(end); % top translation
    Yp((end-nmirror(2)+1):end,:,:) = Yp((end-nmirror(2)+1):end,:,:)+dimensions(2)+dy(1); % bottom translation   
else % ndgrid in 1D, 2D and 3D
    if d==1
        Vp = V(indx);
        Xp = X(indx);
    elseif d==2
        Vp = V(indx,indy);
        Xp = X(indx,indy);
        Yp = Y(indx,indy);
    else
        Vp = V(indx,indy,indz);
        Xp = X(indx,indy,indz);
        Yp = Y(indx,indy,indz);
    end
    Xp(1:nmirror(1),:,:) = Xp(1:nmirror(1),:,:)-dimensions(1)-dx(end); % left translation
    Xp((end-nmirror(1)+1):end,:,:) = Xp((end-nmirror(1)+1):end,:,:)+dimensions(1)+dx(1); % top translation
    if d>1
        Yp(:,1:nmirror(2),:) = Yp(:,1:nmirror(2),:)-dimensions(2)-dy(end); % top translation
        Yp(:,(end-nmirror(2)+1):end,:) = Yp(:,(end-nmirror(2)+1):end,:)+dimensions(2)+dy(1); % bottom translation
    end
end
if d>2
    Zp(:,:,1:nmirror(3)) = Zp(:,:,1:nmirror(3))-dimensions(3)-dz(end); % front translation
    Zp(:,:,(end-nmirror(3)+1):end) = Zp(:,:,(end-nmirror(3)+1):end)+dimensions(3)+dz(1); % back translation
end

%% outputs
if nargout>1, Xout = Xp; end
if nargout>2 && d>1, Yout = Yp; end
if nargout>3 && d>2, Zout = Zp; end

function [Vp,varargout] = PBCgridshift(varargin)
%PBCGRIDSHIFT shift meshgrid/ndgrid meshed values to a vector P assuming periodic boundary conditions
%             and considering the grid created by either meshgrid or ndgrid.
%
%   USAGE in 3D
%       [Vp,Xp,Yp,Zp] = PBCgrid(X,Y,Z,V,P)
%   USAGE in 2D
%       [Vp,Xp,Yp] = PBCgrid(X,Y,V,P)
%   USAGE in 1D
%       [Vp,Xp] = PBCgrid(X,V,P)
%
%   INPUTS (3D):
%            X: a x b x c array created by meshgrid, ndgrid coding for X coordinates
%            Y: a x b x c array created by meshgrid, ndgrid coding for Y coordinates
%            Z: a x b x c array created by meshgrid, ndgrid coding for Z coordinates
%            V: a x b x c array where V(i,j,k) is the value at X(i,j,k), Y(i,j,k) and Z(i,j,k)
%            P: 3 x 1 shift vector (units in grid step)
%               P(1) is the shift along x, P(2) along y, P(3) along z
%
%   INPUTS (2D):
%            X: a x b array created by meshgrid, ndgrid coding for X coordinates
%            Y: a x b array created by meshgrid, ndgrid coding for Y coordinates
%            V: a x b array where V(i,j) is the value at X(i,j) and Y(i,j)
%            P: 2 x 1 shift vector (units in grid step)
%               P(1) is the shift along x, P(2) along y
%
%   INPUTS (1D):
%            X: a x 1 array created by linspace or equivalent
%            V: a x 1 array where V(i) is the value at X(i)
%            P: scalar shift (units in grid step)
%
%   OUTPUTS (1-3D)
%           Vp: array of the same size as V
%           Xp,Yp,Zp corresponding coordinates (with proper translation)
%           preserving the nature of the grid (ndgrid or meshgrid)
%
%
%   Note1: an error is returned if X,Y,Z are not generated by meshgrid or ndgrid
%   Note2: This function assumes a uniform grid
%
%
%
%   See also: PBCgrid, PBCimages, PBCimageschift, PBCincell
%
%
% Example:
%      [X,Y,V] = peaks(100);
%      [Vp,Xp,Yp] = PBCgridshift(X,Y,V,[10 20]);
%      figure, mesh(Xp,Yp,Vp)



% MS 3.0 | 2024-03-24 | INRAE\han.chen@inrae.fr, INRAE\Olivier.vitrac@agroparistech.fr | rev.


% Revision history



% Determine the number of dimensions and validate input
X = varargin{1};
d = ndims(X); %<<- the number of dimensions in X sets 1D, 2D or 3D syntax
if d>3, error('the number of dimensions should be 1,2,3'), end
if d==3 && nargin<5, error('five arguments are at least required in 3D:  [Vp,Xp,Yp,Zp] = PBCgridshift(X,Y,Z,V,P)'), end
if d==2 && nargin<4, error('four arguments are at least required in 2D:  [Vp,Xp,Yp] = PBCgridshift(X,Y,V,P)'), end
if d>1
    Y = varargin{2};
    if ~isequal(size(X),size(Y)), error('X and Y are not compatible'), end
    if d>2 % 3D
        Z = varargin{3};
        if ~isequal(size(X),size(Z)), error('X, Y and Z are not compatible'), end
        V = varargin{4};
        if ~isequal(size(X),size(V)), error('V is not compatible with supplied X, Y and Z'), end
        P = varargin{5};
        if nargin>5, error('4 arguments in 3D'), end
        deltaZ = Z(1,1,2) - Z(1,1,1);
    else % 2D
        V = varargin{3};
        if ~isequal(size(X),size(V)), error('V is not compatible with supplied X and Y'), end
        P = varargin{4};
        if nargin>4, error('4 arguments in 2D'), end
    end
    isMesh = X(1,1,:) == X(2,1,:);
    if isMesh
        deltaX = X(1,2,1) - X(1,1,1);
        deltaY = Y(2,1,1) - Y(1,1,1);
    else % ndgrid
        deltaX = X(2,1,1) - X(1,1,1);
        deltaY = Y(1,2,1) - Y(1,1,1);
    end
else % 1D
    V = varargin{2};
    if ~isequal(size(X),size(V)), error('V is not compatible with supplied X'), end
    P = varargin{3};
    if nargin>3, error('3 arguments in 2D'), end
    isMesh = false; % 1D grid doesn't require meshgrid/ndgrid distinction
    deltaX = X(2)-X(1);
end


% Translate Xp,Yp,Zp
varargout{1} = X + P(1) * deltaX;
if d>1,  varargout{2} = Y + P(2) * deltaY; end
if d==3, varargout{3} = Z + P(3) * deltaZ; end

% Apply periodic boundary condition shift based on the dimensionality
switch d
    case 1
        shift = mod((0:numel(X)-1) + P(1), numel(X)) + 1;
        Vp = V(shift);

    case 2
        [rows, cols] = size(X);
        if isMesh
            rShift = mod((0:rows-1)' + P(2), rows) + 1;
            cShift = mod((0:cols-1) + P(1), cols) + 1;
            Vp = V(rShift, cShift);
        else
            rShift = mod((0:rows-1)' + P(1), rows) + 1;
            cShift = mod((0:cols-1) + P(2), cols) + 1;
            Vp = V(cShift, rShift);
        end

    case 3
        [rows, cols, pages] = size(X);
        zShift = mod((0:pages-1) + P(3), pages) + 1;

        if isMesh
            rShift = mod((0:rows-1)' + P(2), rows) + 1;
            cShift = mod((0:cols-1) + P(1), cols) + 1;
            Vp = V(rShift, cShift, zShift);
        else
            rShift = mod((0:rows-1)' + P(1), rows) + 1;
            cShift = mod((0:cols-1) + P(2), cols) + 1;
            Vp = V(cShift, rShift, zShift);
        end
end

function [Ximages,indXout,copyIdx] = PBCimages(X,box,PBC,cutoff)
%PBCIMAGES return the coordinates of fictive particle images outside box limits along periodic boundary dimensions
%
%   USAGE: Ximages = PBCimages(X,box,PBC [,cutoff])
%          [Ximages,indX,copyIdx] = PBCimages(...)
%
%   INPUTS:
%          X: nx2 or nx3 array coding for the coordinates of the n particles in 2D and 3D, respectively
%        box: 2x2 or 3x2 array coding for box dimensions
%             the box spans along dimension i between box(i,1) and box(i,2)
%             all X values should lie within box limits, if not an error is generated
%        PBC: 1x2 or 1x3 boolean array
%             PBC(i) is true if the dimension i is periodic
%     cutoff: scalar or 1xd array with d the number of dimensions (2 or 3)
%             setting the cutoff distance beyond bounds to include fictive images
%             if cutoff is a scalar, it is redefined as cutoff(ones(1,d))
%             cutoff(i) is applied along dimension i
%
%   OUTPUTS:
%    Ximages: mx2 or mx3 array coding for the coordinates of the m particle images in 2D and 3D, respectively
%       indX: corresponding indices of images in X
%    copyIdx: indices of the copies of each atom created (starting from 1)
%
%   See also: PBCgrid, PBCgridshift, PBCimageschift, PBCincell
%
% 
%  NOTE about copyIdx and its values (2D: maximum value = 5, 3D: maximum value = 26)
% 
% In 2D.   Each dimension can generate two types of images: lower and upper images.
%          If both dimensions are periodic: there are additional corner images.
%               Lower images for dimension 1: copyIdx = 1
%               Upper images for dimension 1: copyIdx = 2
%               Lower images for dimension 2: copyIdx = 3
%               Upper images for dimension 2: copyIdx = 4
%               Corner images (4 possible combinations): copyIdx = 5
% In 3D.   If all three dimensions are periodic: there are additional corner images.
%          If at least two dimensions are periodic: there are additional edge images.
%               Lower images for dimension 1: copyIdx = 1
%               Upper images for dimension 1: copyIdx = 2
%               Lower images for dimension 2: copyIdx = 3
%               Upper images for dimension 2: copyIdx = 4
%               Lower images for dimension 3: copyIdx = 5
%               Upper images for dimension 3: copyIdx = 6
%               Edge images (12 possible combinations): copyIdx = 7, 8, ..., 18
%               Corner images (8 possible combinations): copyIdx = 19, 20, ..., 26


% Full example in 2D
%{
    % Parameters
    n_particles = 10000;
    box = [0 10; 0 10]; % Box limits for 2D
    PBC = [true, true]; % Periodic boundary conditions in both dimensions
    cutoff = 3.0; % Cutoff distance
    
    % Generate random particles within the box
    X = rand(n_particles, 2) .* (box(:,2) - box(:,1))' + box(:,1)';
    
    % Calculate fictive images
    [Ximages, indX, copyIdx] = PBCimages(X, box, PBC, cutoff);
    
    % Plotting
    figure, hold on
    plot(X(:,1), X(:,2), 'k.', 'MarkerSize', 15); % Original particles in black
    
    % Define a colormap for different copyIdx values
    colormap = lines(max(copyIdx));
    for i = 1:max(copyIdx)
        idx = (copyIdx == i);
        plot(Ximages(idx,1), Ximages(idx,2), '.', 'MarkerSize', 15, 'Color', colormap(i, :)); % Images with different colors
    end
    
    xlim([box(1,1) - 2*cutoff, box(1,2) + 2*cutoff]);
    ylim([box(2,1) - 2*cutoff, box(2,2) + 2*cutoff]);
    xlabel('X');
    ylabel('Y');
    title('Original Particles and Their Fictive Images');
    
    % Create legend
    legendEntries = arrayfun(@(i) sprintf('Copy %d', i), 1:max(copyIdx), 'UniformOutput', false);
    legend(['Original Particles', legendEntries]);
    
    grid on, axis equal

%}

% Full example in 3D
%{
    % Parameters
    n_particles = 10000;
    box = [0 10; 0 10; 0 10]; % Box limits for 3D
    PBC = [true, true, true]; % Periodic boundary conditions in all dimensions
    cutoff = 3.0; % Cutoff distance
    
    % Generate random particles within the box
    X = rand(n_particles, 3) .* (box(:,2) - box(:,1))' + box(:,1)';
    
    % Calculate fictive images
    [Ximages, indX, copyIdx] = PBCimages(X, box, PBC, cutoff);
    
    % Plotting
    figure, hold on
    plot3(X(:,1), X(:,2), X(:,3), 'k.', 'MarkerSize', 15); % Original particles in black
    
    % Define a colormap for different copyIdx values
    %colormap = lines(max(copyIdx));
    % Define a more diverse set of colors (compact definition)
    colormap = [0, 0, 1; 0, 1, 0; 1, 0, 0; 0, 1, 1; 1, 0, 1; 1, 1, 0;
            0.5, 0, 0; 0, 0.5, 0; 0, 0, 0.5; 0.5, 0.5, 0; 0.5, 0, 0.5;
            0, 0.5, 0.5; 0.75, 0.25, 0.25; 0.25, 0.75, 0.25; 0.25, 0.25, 0.75;
            0.75, 0.75, 0.25; 0.75, 0.25, 0.75; 0.25, 0.75, 0.75; 0.5, 0.5, 0.5;
            0.75, 0.75, 0.75; 0.25, 0.25, 0.25; 1, 0.5, 0; 0, 1, 0.5;
            0.5, 0, 1; 0, 0.5, 1; 1, 0, 0.5];
    for i = 1:max(copyIdx)
        idx = (copyIdx == i);
        plot3(Ximages(idx,1), Ximages(idx,2), Ximages(idx,3), '.', 'MarkerSize', 15, 'Color', colormap(i, :)); % Images with different colors
    end
    
    xlim([box(1,1) - 2*cutoff, box(1,2) + 2*cutoff]);
    ylim([box(2,1) - 2*cutoff, box(2,2) + 2*cutoff]);
    zlim([box(3,1) - 2*cutoff, box(3,2) + 2*cutoff]);
    xlabel('X'); ylabel('Y'); zlabel('Z');
    title('Original Particles and Their Fictive Images');
    
    % Create legend
    legendEntries = arrayfun(@(i) sprintf('Copy %d', i), 1:max(copyIdx), 'UniformOutput', false);
    legend(['Original Particles', legendEntries]);
    
    grid on;
    hold off;
    axis equal;
    view(3);

%}


% MS 3.0 | 2024-03-15 | INRAE\han.chen@inrae.fr, INRAE\Olivier.vitrac@agroparistech.fr | rev. 2024-07-16


% Revision history
% 2024-03-15 release candidate with examples in 2D and 3D
% 2024-03-16 return indX, advise using PBCincell if particles outside are detected
% 2024-07-16 add copyIdx and extend 2D and 3D examples to exemplify all copy possibilities

%% Check arguments
if nargin<3, error('Not enough input arguments. Syntax: Ximages = PBCimages(X,box,PBC [,cutoff])'), end
if nargin<4, cutoff = []; end
[n,d] = size(X); % Number of particles and dimensions
if d>3, error('the number of dimensions should be 1,2,3'), end
Xmin = min(X);
Xmax = max(X);
if isempty(cutoff), cutoff = 0.1*(Xmax-Xmin); end % heuristic default value
if length(cutoff)==1, cutoff = cutoff(ones(1,d)); end
if length(cutoff)~=d, error('cutoff must be a scalar or 1x%d vector',d); end
if size(box,2)~=2 || size(box,1)~=d, error('Box dimensions must be a %dx2 vector',d); end
boxlength = diff(box, 1, 2);
if length(PBC)~=d; error('PBC must be a 1x%d logical vector',d), end
PBC = PBC>0;

%% Check that all points lie within the box
incellok = true;
for i=1:d
    if box(i,1)>Xmin(i)
        dispf('some particles are outside the lower bound %0.3g along dimension %d',box(i,1),i)
        incellok = false;
    end
    if box(i,2)'some particles are outside the upper bound %0.3g along dimension %d',box(i,2),i),
        incellok = false;
    end
end
if ~incellok
    disp('use: X = PBCincell(X,box,PBC) to wrap particles around coordinates')
    error('PBCimages: some particles outside the box...')
end

%% Initialize empty array for images
[Ximages,indX,copyIdx] = deal([]);
copyCounter = 0; % Counter to track the number of copies

%% Generate images for each dimension independently
for i = 1:d
    if PBC(i)
        lowerBound = box(i,1);
        upperBound = box(i,2);

        % Lower and upper images
        islowerImages = X(:, i) < (lowerBound + cutoff(i));
        lowerImages = X(islowerImages, :);
        lowerImages(:, i) = lowerImages(:, i) + (upperBound - lowerBound);

        isupperimages = X(:, i) > (upperBound - cutoff(i));
        upperImages = X(isupperimages, :);
        upperImages(:, i) = upperImages(:, i) - (upperBound - lowerBound);

        Ximages = [Ximages; lowerImages; upperImages]; %#ok
        indX = [indX; find(islowerImages); find(isupperimages)]; %#ok
        copyIdx = [copyIdx; repmat(copyCounter+1, sum(islowerImages), 1); repmat(copyCounter+2, sum(isupperimages), 1)]; %#ok
        copyCounter = copyCounter + 2; % Update the copy counter
    end
end

%% Generate corner images if all dimensions are periodic
if all(PBC)
    % Find all combinations for corners
    if d==2
        [x,y]=meshgrid([0 1],[0 1]);
        corners = [x(:) y(:)];
    elseif d==3
        [x,y,z]=meshgrid([0 1],[0 1],[0 1]);
        corners = [x(:) y(:) z(:)];
    end    
    for i = 1:size(corners, 1) % 4 (in 2D), 8 (in 3D)
        cornerCond = true(n, 1);
        cornerImages = X;
        for j = 1:d
            if corners(i,j) == 0
                % Lower corner images
                thisCorner = X(:,j) < (box(j,1) + cutoff(j));
                cornerImages(thisCorner,j) = cornerImages(thisCorner,j) + boxlength(j);
            else
                % Upper corner images
                thisCorner = X(:,j) > (box(j,2) - cutoff(j));
                cornerImages(thisCorner,j) = cornerImages(thisCorner,j) - boxlength(j);
            end
            cornerCond = cornerCond & thisCorner;
        end
        % Add corner images if any particles satisfy the corner condition
        if any(cornerCond)
            Ximages = [Ximages; cornerImages(cornerCond, :)]; %#ok
            indX = [indX; find(cornerCond)]; %#ok
            copyIdx = [copyIdx; repmat(copyCounter+1, sum(cornerCond), 1)]; %#ok
            copyCounter = copyCounter + 1; % Update the copy counter
        end
    end
end

%% Generate edge images if two dimensions are at least periodic in 3D
if (d==3) && (sum(PBC)>1)
    dvalid = find(PBC);
    [x,y] = meshgrid(dvalid,dvalid); ok = (x% dimension pairs (with x
    [x,y]=meshgrid([0 1],[0 1]);
    edges = [x(:) y(:)]; % edge pairs
    
    for k = 1:size(dimforedges,1) % number of dimension pairs (max 3)
        for i = 1:size(edges, 1)  % number of lower/upper edges (4) ==> 3x4 = 12 edges at maximum
            edgeCond = true(n, 1);
            edgeImages = X;
            for j = 1:2 % for edges in 3D (2 dimensions only)
                jdim = dimforedges(k,j);
                if edges(i,j) == 0
                    % Lower edge images
                    thisEdge = X(:,jdim) < (box(jdim,1) + cutoff(jdim));
                    edgeImages(thisEdge,jdim) = edgeImages(thisEdge,jdim) + boxlength(jdim);
                else
                    % Upper edge images
                    thisEdge = X(:,jdim) > (box(jdim,2) - cutoff(jdim));
                    edgeImages(thisEdge,jdim) = edgeImages(thisEdge,jdim) - boxlength(jdim);
                end
            end
            edgeCond = edgeCond & thisEdge;
            % Add edge images if any particles satisfy the edge condition
            if any(edgeCond)
                Ximages = [Ximages; edgeImages(edgeCond, :)]; %#ok
                indX = [indX; find(edgeCond)]; %#ok
                copyIdx = [copyIdx; repmat(copyCounter+1, sum(edgeCond), 1)]; %#ok
                copyCounter = copyCounter + 1; % Update the copy counter
            end
        end
    end
end

%% Removing duplicates if any
[Ximages,iXuniq] = unique(Ximages, 'rows');
indX = indX(iXuniq);
copyIdx = copyIdx(iXuniq);

% output
if nargout>1, indXout = indX; end
if nargout>2, copyIdx = copyIdx; end
end


%% --- version before 2024-08-16
% function [Ximages,indXout] = PBCimages(X,box,PBC,cutoff)
% %PBCIMAGES return the coordinates of fictive particle images outside box limits along periodic boundary dimensions
% %
% %   USAGE: Ximages = PBCimages(X,box,PBC [,cutoff])
% %          [Ximages,indX] = PBCimages(...)
% %
% %   INPUTS:
% %          X: nx2 or nx3 array coding for the coordinates of the n particles in 2D and 3D, respectively
% %        box: 2x2 or 3x2 array coding for box dimensions
% %             the box spans along dimension i between box(i,1) and box(i,2)
% %             all X values should lie within box limits, if not an error ois generated
% %        PBC: 1x2 or 1x3 boolean array
% %             PBC(i) is true if the dimension i is periodic
% %     cutoff: scalar or 1xd array with d the number of dimensions (2 or 3)
% %             setting the cutoff distance beyond bounds to include fictive images
% %             if cutoff is a scalar, it is refedined as cutoff(ones(1,d))
% %             cutoff(i) is applied along dimension i
% %
% %   OUTPUTS:
% %    Ximages: mx2 or mx3 array coding for the coordinates of the m particle images in 2D and 3D, respectively
% %       indX: corresponding indices of images in X
% %
% %
% %   See also: PBCgrid, PBCgridshift, PBCimageschift, PBCincell
% %
% 
% % Full example in 2D
% %{
%     % Parameters
%     n_particles = 10000;
%     box = [0 10; 0 10]; % Box limits for 2D
%     PBC = [true, true]; % Periodic boundary conditions in both dimensions
%     cutoff = 3.0; % Cutoff distance
% 
%     % Generate random particles within the box
%     X = rand(n_particles, 2) .* (box(:,2) - box(:,1))' + box(:,1)';
% 
%     % Calculate fictive images
%     Ximages = PBCimages(X, box, PBC, cutoff);
% 
%     % Plotting
%     figure, hold on
%     plot(X(:,1), X(:,2), 'g.', 'MarkerSize', 15); % Original particles in green
%     if ~isempty(Ximages)
%         plot(Ximages(:,1), Ximages(:,2), 'b.', 'MarkerSize', 15); % Images in blue
%     end
%     xlim([box(1,1) - 2*cutoff, box(1,2) + 2*cutoff]);
%     ylim([box(2,1) - 2*cutoff, box(2,2) + 2*cutoff]);
%     xlabel('X');
%     ylabel('Y');
%     title('Original Particles and Their Fictive Images');
%     legend('Original Particles', 'Fictive Images');
%     grid on;
%     hold off;
%     axis equal
% %}
% 
% % Full example in 3D
% %{
%     % Parameters
%     n_particles = 10000;
%     box = [0 10; 0 10; 0 10]; % Box limits for 3D
%     PBC = [true, true, true]; % Periodic boundary conditions in both dimensions
%     cutoff = 3.0; % Cutoff distance
% 
%     % Generate random particles within the box
%     X = rand(n_particles, 3) .* (box(:,2) - box(:,1))' + box(:,1)';
% 
%     % Calculate fictive images
%     Ximages = PBCimages(X, box, PBC, cutoff);
% 
%     % Plotting
%     figure, hold on
%     plot3(X(:,1), X(:,2), X(:,3), 'g.', 'MarkerSize', 15); % Original particles in green
%     plot3(Ximages(:,1), Ximages(:,2),Ximages(:,3), 'b.', 'MarkerSize', 15); % Images in blue
%     xlim([box(1,1) - 2*cutoff, box(1,2) + 2*cutoff]);
%     ylim([box(2,1) - 2*cutoff, box(2,2) + 2*cutoff]);
%     zlim([box(3,1) - 2*cutoff, box(3,2) + 2*cutoff]);
%     xlabel('X'); ylabel('Y'); ylabel('Z'); title('Original Particles and Their Fictive Images');
%     legend('Original Particles', 'Fictive Images');
%     grid on, hold off, axis equal, view(3)
% %}
% 
% 
% % MS 3.0 | 2024-03-15 | INRAE\han.chen@inrae.fr, INRAE\Olivier.vitrac@agroparistech.fr | rev. 2024-03-16
% 
% 
% % Revision history
% % 2024-03-15 release canidate with examples in 2D and 3D
% % 2024-03-16 return indX, advise using PBCincell if particles outside are detected
% 
% %% Check arguments
% if nargin<3, error('Not enough input arguments. Syntax: Ximages = PBCimages(X,box,PBC [,cutoff])'), end
% if nargin<4, cutoff = []; end
% [n,d] = size(X); % Number of particles and dimensions
% if d>3, error('the number of dimensions should be 1,2,3'), end
% Xmin = min(X);
% Xmax = max(X);
% if isempty(cutoff), cutoff = 0.1*(Xmax-Xmin); end % heuristic default value
% if length(cutoff)==1, cutoff = cutoff(ones(1,d)); end
% if length(cutoff)~=d, error('cutoff must be a scalar or 1x%d vector',d); end
% if size(box,2)~=2 || size(box,1)~=d, error('Box dimensions must be a %dx2 vector',d); end
% boxlength = diff(box, 1, 2);
% if length(PBC)~=d; error('PBC must be a 1x%d logical vector',d), end
% PBC = PBC>0;
% 
% %% Check that all points lie within the box
% incellok = true;
% for i=1:d
%     if box(i,1)>Xmin(i)
%         dispf('some particles are outside the lower bound %0.3g along dimension %d',box(i,1),i)
%         incellok = false;
%     end
%     if box(i,2)
%         dispf('some particles are outside the upper bound %0.3g along dimension %d',box(i,2),i),
%         incellok = false;
%     end
% end
% if ~incellok
%     disp('use: X = PBCincell(X,box,PBC) to wrap particles around coordinates')
%     error('PBCimages: some particles outside the box...')
% end
% 
% %% Initialize empty array for images
% [Ximages,indX] = deal([]);
% 
% %% Generate images for each dimension independently
% for i = 1:d
%     if PBC(i)
%         lowerBound = box(i,1);
%         upperBound = box(i,2);
% 
%         % Lower and upper images
%         islowerImages = X(:, i) < (lowerBound + cutoff(i));
%         lowerImages = X(islowerImages, :);
%         lowerImages(:, i) = lowerImages(:, i) + (upperBound - lowerBound);
% 
%         isupperimages = X(:, i) > (upperBound - cutoff(i));
%         upperImages = X(isupperimages, :);
%         upperImages(:, i) = upperImages(:, i) - (upperBound - lowerBound);
% 
%         Ximages = [Ximages; lowerImages; upperImages]; %#ok
%         indX = [indX;find(islowerImages);find(isupperimages)]; %#ok
%     end
% end
% 
% %% Generate corner images if all dimensions are periodic
% if all(PBC)
%     % Find all combinations for corners
%     % corners = dec2bin(1:(2^d)-1) - '0';
%     if d==2
%         [x,y]=meshgrid([0 1],[0 1]);
%         corners = [x(:) y(:)];
%     elseif d==3
%         [x,y,z]=meshgrid([0 1],[0 1],[0 1]);
%         corners = [x(:) y(:) z(:)];
%     end
% 
%     for i = 1:size(corners, 1) % 4 (in 2D), 8 (in 3D)
%         cornerCond = true(n, 1);
%         cornerImages = X;
%         for j = 1:d
%             if corners(i,j) == 0
%                 % Lower corner images
%                 thisCorner = X(:,j) < (box(j,1) + cutoff(j));
%                 cornerImages(thisCorner,j) = cornerImages(thisCorner,j) + boxlength(j);
%             else
%                 % Upper corner images
%                 thisCorner = X(:,j) > (box(j,2) - cutoff(j));
%                 cornerImages(thisCorner,j) = cornerImages(thisCorner,j) - boxlength(j);
%             end
%             cornerCond = cornerCond & thisCorner;
%         end
%         % Add corner images if any particles satisfy the corner condition
%         if any(cornerCond)
%             Ximages = [Ximages; cornerImages(cornerCond, :)]; %#ok
%             indX = [indX;find(cornerCond)]; %#ok
%         end
%     end
% end
% 
% %% Generate edge images if two dimensions are at least periodic in 3D
% if (d==3) && (sum(PBC)>1)
%     dvalid = find(PBC);
%     [x,y] = meshgrid(dvalid,dvalid); ok = (x
%     dimforedges = [x(ok) y(ok)]; % dimension pairs (with x
%     [x,y]=meshgrid([0 1],[0 1]);
%     edges = [x(:) y(:)]; % edge pairs
% 
%     for k = 1:size(dimforedges,1) % number of dimension pairs (max 3)
%         for i = 1:size(edges, 1)  % number of lower/upper edges (4) ==> 3x4 = 12 edges at maximum
%             edgeCond = true(n, 1);
%             edgeImages = X;
%             for j = 1:2 % for edges in 3D (2 dimensions only)
%                 jdim = dimforedges(k,j);
%                 if edges(i,j) == 0
%                     % Lower edge images
%                     thisEdge = X(:,jdim) < (box(jdim,1) + cutoff(jdim));
%                     edgeImages(thisEdge,jdim) = edgeImages(thisEdge,jdim) + boxlength(jdim);
%                 else
%                     % Upper edge images
%                     thisEdge = X(:,jdim) > (box(jdim,2) - cutoff(jdim));
%                     edgeImages(thisEdge,jdim) = edgeImages(thisEdge,jdim) - boxlength(jdim);
%                 end
%             end
%             edgeCond = edgeCond & thisEdge;
%             % Add corner images if any particles satisfy the edge condition
%             if any(edgeCond)
%                 Ximages = [Ximages; edgeImages(edgeCond, :)]; %#ok
%                 indX = [indX;find(edgeCond)]; %#ok
%             end
%         end
%     end
% end
% 
% 
% %% Removing duplicates if any
% [Ximages,iXuniq] = unique(Ximages, 'rows');
% indX = indX(iXuniq);
% 
% % output
% if nargout>1, indXout = indX; end

function [Ximages,indXout] = PBCimages0(X,box,PBC,cutoff)
%PBCIMAGES return the coordinates of fictive particle images outside box limits along periodic boundary dimensions
%
%   USAGE: Ximages = PBCimages(X,box,PBC [,cutoff])
%          [Ximages,indX] = PBCimages(...)
%
%   INPUTS:
%          X: nx2 or nx3 array coding for the coordinates of the n particles in 2D and 3D, respectively
%        box: 2x2 or 3x2 array coding for box dimensions
%             the box spans along dimension i between box(i,1) and box(i,2)
%             all X values should lie within box limits, if not an error ois generated
%        PBC: 1x2 or 1x3 boolean array
%             PBC(i) is true if the dimension i is periodic
%     cutoff: scalar or 1xd array with d the number of dimensions (2 or 3)
%             setting the cutoff distance beyond bounds to include fictive images
%             if cutoff is a scalar, it is refedined as cutoff(ones(1,d))
%             cutoff(i) is applied along dimension i
%
%   OUTPUTS:
%    Ximages: mx2 or mx3 array coding for the coordinates of the m particle images in 2D and 3D, respectively
%       indX: corresponding indices of images in X
%
%
%   See also: PBCgrid, PBCgridshift, PBCimageschift, PBCincell
%

% Full example in 2D
%{
    % Parameters
    n_particles = 10000;
    box = [0 10; 0 10]; % Box limits for 2D
    PBC = [true, true]; % Periodic boundary conditions in both dimensions
    cutoff = 3.0; % Cutoff distance

    % Generate random particles within the box
    X = rand(n_particles, 2) .* (box(:,2) - box(:,1))' + box(:,1)';

    % Calculate fictive images
    Ximages = PBCimages(X, box, PBC, cutoff);

    % Plotting
    figure, hold on
    plot(X(:,1), X(:,2), 'g.', 'MarkerSize', 15); % Original particles in green
    if ~isempty(Ximages)
        plot(Ximages(:,1), Ximages(:,2), 'b.', 'MarkerSize', 15); % Images in blue
    end
    xlim([box(1,1) - 2*cutoff, box(1,2) + 2*cutoff]);
    ylim([box(2,1) - 2*cutoff, box(2,2) + 2*cutoff]);
    xlabel('X');
    ylabel('Y');
    title('Original Particles and Their Fictive Images');
    legend('Original Particles', 'Fictive Images');
    grid on;
    hold off;
    axis equal
%}

% Full example in 3D
%{
    % Parameters
    n_particles = 10000;
    box = [0 10; 0 10; 0 10]; % Box limits for 3D
    PBC = [true, true, true]; % Periodic boundary conditions in both dimensions
    cutoff = 3.0; % Cutoff distance

    % Generate random particles within the box
    X = rand(n_particles, 3) .* (box(:,2) - box(:,1))' + box(:,1)';

    % Calculate fictive images
    Ximages = PBCimages(X, box, PBC, cutoff);

    % Plotting
    figure, hold on
    plot3(X(:,1), X(:,2), X(:,3), 'g.', 'MarkerSize', 15); % Original particles in green
    plot3(Ximages(:,1), Ximages(:,2),Ximages(:,3), 'b.', 'MarkerSize', 15); % Images in blue
    xlim([box(1,1) - 2*cutoff, box(1,2) + 2*cutoff]);
    ylim([box(2,1) - 2*cutoff, box(2,2) + 2*cutoff]);
    zlim([box(3,1) - 2*cutoff, box(3,2) + 2*cutoff]);
    xlabel('X'); ylabel('Y'); ylabel('Z'); title('Original Particles and Their Fictive Images');
    legend('Original Particles', 'Fictive Images');
    grid on, hold off, axis equal, view(3)
%}


% MS 3.0 | 2024-03-15 | INRAE\han.chen@inrae.fr, INRAE\Olivier.vitrac@agroparistech.fr | rev. 2024-03-16


% Revision history
% 2024-03-15 release canidate with examples in 2D and 3D
% 2024-03-16 return indX, advise using PBCincell if particles outside are detected

%% Check arguments
if nargin<3, error('Not enough input arguments. Syntax: Ximages = PBCimages(X,box,PBC [,cutoff])'), end
if nargin<4, cutoff = []; end
[n,d] = size(X); % Number of particles and dimensions
if d>3, error('the number of dimensions should be 1,2,3'), end
Xmin = min(X);
Xmax = max(X);
if isempty(cutoff), cutoff = 0.1*(Xmax-Xmin); end % heuristic default value
if length(cutoff)==1, cutoff = cutoff(ones(1,d)); end
if length(cutoff)~=d, error('cutoff must be a scalar or 1x%d vector',d); end
if size(box,2)~=2 || size(box,1)~=d, error('Box dimensions must be a %dx2 vector',d); end
boxlength = diff(box, 1, 2);
if length(PBC)~=d; error('PBC must be a 1x%d logical vector',d), end
PBC = PBC>0;

%% Check that all points lie within the box
incellok = true;
for i=1:d
    if box(i,1)>Xmin(i)
        dispf('some particles are outside the lower bound %0.3g along dimension %d',box(i,1),i)
        incellok = false;
    end
    if box(i,2)'some particles are outside the upper bound %0.3g along dimension %d',box(i,2),i),
        incellok = false;
    end
end
if ~incellok
    disp('use: X = PBCincell(X,box,PBC) to wrap particles around coordinates')
    error('PBCimages: some particles outside the box...')
end

%% Initialize empty array for images
[Ximages,indX] = deal([]);

%% Generate images for each dimension independently
for i = 1:d
    if PBC(i)
        lowerBound = box(i,1);
        upperBound = box(i,2);

        % Lower and upper images
        islowerImages = X(:, i) < (lowerBound + cutoff(i));
        lowerImages = X(islowerImages, :);
        lowerImages(:, i) = lowerImages(:, i) + (upperBound - lowerBound);

        isupperimages = X(:, i) > (upperBound - cutoff(i));
        upperImages = X(isupperimages, :);
        upperImages(:, i) = upperImages(:, i) - (upperBound - lowerBound);

        Ximages = [Ximages; lowerImages; upperImages]; %#ok
        indX = [indX;find(islowerImages);find(isupperimages)]; %#ok
    end
end

%% Generate corner images if all dimensions are periodic
if all(PBC)
    % Find all combinations for corners
    % corners = dec2bin(1:(2^d)-1) - '0';
    if d==2
        [x,y]=meshgrid([0 1],[0 1]);
        corners = [x(:) y(:)];
    elseif d==3
        [x,y,z]=meshgrid([0 1],[0 1],[0 1]);
        corners = [x(:) y(:) z(:)];
    end

    for i = 1:size(corners, 1) % 4 (in 2D), 8 (in 3D)
        cornerCond = true(n, 1);
        cornerImages = X;
        for j = 1:d
            if corners(i,j) == 0
                % Lower corner images
                thisCorner = X(:,j) < (box(j,1) + cutoff(j));
                cornerImages(thisCorner,j) = cornerImages(thisCorner,j) + boxlength(j);
            else
                % Upper corner images
                thisCorner = X(:,j) > (box(j,2) - cutoff(j));
                cornerImages(thisCorner,j) = cornerImages(thisCorner,j) - boxlength(j);
            end
            cornerCond = cornerCond & thisCorner;
        end
        % Add corner images if any particles satisfy the corner condition
        if any(cornerCond)
            Ximages = [Ximages; cornerImages(cornerCond, :)]; %#ok
            indX = [indX;find(cornerCond)]; %#ok
        end
    end
end

%% Generate edge images if two dimensions are at least periodic in 3D
if (d==3) && (sum(PBC)>1)
    dvalid = find(PBC);
    [x,y] = meshgrid(dvalid,dvalid); ok = (x% dimension pairs (with x
    [x,y]=meshgrid([0 1],[0 1]);
    edges = [x(:) y(:)]; % edge pairs

    for k = 1:size(dimforedges,1) % number of dimension pairs (max 3)
        for i = 1:size(edges, 1)  % number of lower/upper edges (4) ==> 3x4 = 12 edges at maximum
            edgeCond = true(n, 1);
            edgeImages = X;
            for j = 1:2 % for edges in 3D (2 dimensions only)
                jdim = dimforedges(k,j);
                if edges(i,j) == 0
                    % Lower edge images
                    thisEdge = X(:,jdim) < (box(jdim,1) + cutoff(jdim));
                    edgeImages(thisEdge,jdim) = edgeImages(thisEdge,jdim) + boxlength(jdim);
                else
                    % Upper edge images
                    thisEdge = X(:,jdim) > (box(jdim,2) - cutoff(jdim));
                    edgeImages(thisEdge,jdim) = edgeImages(thisEdge,jdim) - boxlength(jdim);
                end
            end
            edgeCond = edgeCond & thisEdge;
            % Add corner images if any particles satisfy the edge condition
            if any(edgeCond)
                Ximages = [Ximages; edgeImages(edgeCond, :)]; %#ok
                indX = [indX;find(edgeCond)]; %#ok
            end
        end
    end
end


%% Removing duplicates if any
[Ximages,iXuniq] = unique(Ximages, 'rows');
indX = indX(iXuniq);

% output
if nargout>1, indXout = indX; end

function [Ximages,updtbox] = PBCimagesshift(X,Pshift,box)
%PBCIMAGESSHIFT shift X coordinates assuming periodic conditions
%
%   USAGE: Ximages = PBCimages(X,box,Pshift)
%          [Ximages,updtbox] = PBCimages(...)
%
%   INPUTS:
%          X: nx2 or nx3 array coding for the coordinates of the n particles in 2D and 3D, respectively
%     Pshift: 1x2 or 1x3 array coding for the translation to apply
%        box: 2x2 or 3x2 array coding for current box dimensions (before translation)
%             the box spans along dimension i between box(i,1) and box(i,2)
%             all X values should lie within box limits, if not an error is generated
%
%   OUTPUTS:
%    Ximages: nx2 or nx3 array coding for the translated coordinates wrapped around periodic boundaries
%    updtbox: 2x2 or 3x3 updated box coordinates
%
%
%   See also: PBCgrid, PBCgridshift, PBCimages, PBCincell



% MS 3.0 | 2024-03-24 | INRAE\han.chen@inrae.fr, INRAE\Olivier.vitrac@agroparistech.fr | rev. 2024-03-16


% Revision history


%% Check arguments
if nargin<3, error('Not enough input arguments. Syntax: Ximages = PBCimagesshift(X,Pshift,box)'), end
[n,d] = size(X); % Number of particles and dimensions
if d>3, error('the number of dimensions should be 1,2,3'), end
Xmin = min(X);
Xmax = max(X);
if size(box,2)~=2 || size(box,1)~=d, error('Box dimensions must be a %dx2 vector',d); end
boxlength = diff(box, 1, 2);

%% Check that all points lie within the box
incellok = true;
for i=1:d
    if box(i,1)>Xmin(i)
        dispf('some particles are outside the lower bound %0.3g along dimension %d',box(i,1),i)
        incellok = false;
    end
    if box(i,2)'some particles are outside the upper bound %0.3g along dimension %d',box(i,2),i),
        incellok = false;
    end
end
if ~incellok
    disp('use: X = PBCincell(X,box,PBC) to wrap particles around coordinates')
    error('PBCimages: some particles outside the box...')
end


%% Apply shift and wrap around using periodic boundary conditions
boxtranslated = zeros(size(box));
Ximages = zeros(size(X),class(X));
for i = 1:d
    boxtranslated(i,:) = box(i,:) - Pshift(i);
    Ximages(:, i) = mod(X(:, i) - box(i, 1) + Pshift(i), boxlength(i)) + boxtranslated(i, 1);
end

%% Output
if nargout>1
    updtbox = boxtranslated;
end

function Xincell = PBCincell(X,box,PBC)
%PBCINCELL force incell coordinates (without X coordinates outside the box along perodic coordinates)
%
%   USAGE: Xincell = PBCincell(X,box,PBC)
%
%   INPUTS:
%          X: nx2 or nx3 array coding for the coordinates of the n particles in 2D and 3D, respectively
%        box: 2x2 or 3x2 array coding for box dimensions
%             the box spans along dimension i between box(i,1) and box(i,2)
%        PBC: 1x2 or 1x3 boolean array
%             PBC(i) is true if the dimension i is periodic
%
%   OUTPUTS:
%    Xincell: nx2 or nx3 array coding for the coordinates incell
%
%
%
%   See also: PBCgrid, PBCgridshift, PBCimages, PBCimageschift, PBCincell



% MS 3.0 | 2024-03-16 | INRAE\han.chen@inrae.fr, INRAE\Olivier.vitrac@agroparistech.fr |


% Revision history


% Initialize the output array with the same size as input coordinates
Xincell = X;

% Number of dimensions (2D or 3D)
dims = size(X, 2);

% Loop over each dimension to apply periodic boundary conditions
for i = 1:dims
    if PBC(i)
        % Get the box size for the current dimension
        boxSize = box(i, 2) - box(i, 1);
        % Adjust positions for periodic boundary conditions
        % Use mod to wrap coordinates within the box dimensions
        Xincell(:, i) = mod(X(:, i) - box(i, 1), boxSize) + box(i, 1);
    end
end

function [XYZout, isReunitedout] = PBCoutcell(XYZ, box, PBC)
%PBCOUTCELL reunite atoms crossing PBC boundaries on one side based on the centroid's location
%
%   USAGE: XYZout = PBCoutcell(XYZ, box, PBC)
%          [XYZout, isReunited] = PBCoutcell(...)
%
%   INPUTS:
%          XYZ: nx2 or nx3 array coding for the coordinates of the n atoms in 2D or 3D
%          box: 2x2 or 3x2 array coding for box dimensions
%               the box spans along dimension i between box(i,1) and box(i,2)
%          PBC: 1x2 or 1x3 boolean array
%               PBC(i) is true if the dimension i is periodic
%
%   OUTPUT:
%       XYZout: nx2 or nx3 array with coordinates adjusted to reunite atoms on one side of the boundaries
%   isReunited: true if reunion has been applied

% Example in 2D:
%{
    % Box limits
    box = [0 10; 0 10];
    % PBC in both dimensions
    PBC = [true, true];
    % Generate random points in a disk
    n_particles = 10000;
    radius = 0.55 * min(box(:,2) - box(:,1)) / 2;
    theta = 2 * pi * rand(n_particles, 1);
    r = radius * sqrt(rand(n_particles, 1));
    center = (box(:,2) - box(:,1))' .* rand(1, 2) + box(:,1)';
    XYZ0 = [center(1) + r .* cos(theta), center(2) + r .* sin(theta)];
    % Apply PBC to bring coordinates within the box
    XYZ = PBCincell(XYZ0,box,PBC);
    XYZout = PBCoutcell(XYZ, box, PBC);
    % Plotting
    figure, hold on
    plot(XYZ0(:,1), XYZ0(:,2), 'g.', 'MarkerSize', 10); % OUTCELL Original points in green
    plot(XYZ(:,1), XYZ(:,2), 'r.', 'MarkerSize', 10); % Original INCELL points in red
    plot(XYZout(:,1), XYZout(:,2), 'b.', 'MarkerSize', 10); % Adjusted points in blue
    xlabel('X'); ylabel('Y'); title('Reunited Atoms in 2D');
    legend('True', 'Original', 'Adjusted');
    grid on; axis equal; hold off;
%}
%
% Example in 3D:
%{
    % Box limits
    box = [0 10; 0 10; 0 10];
    % PBC in all dimensions
    PBC = [true, true, true];
    % Generate random points in a sphere
    n_particles = 10000;
    radius = 4.4*0.25 * min(box(:,2) - box(:,1)) / 2;
    phi = 2 * pi * rand(n_particles, 1);
    costheta = 2 * rand(n_particles, 1) - 1;
    u = rand(n_particles, 1);
    theta = acos(costheta);
    r = radius * u.^(1/3);
    center = (box(:,2) - box(:,1))' .* rand(1, 3) + box(:,1)';
    XYZ0 = [center(1) + r .* sin(theta) .* cos(phi), ...
           center(2) + r .* sin(theta) .* sin(phi), ...
           center(3) + r .* cos(theta)];
    % Apply PBC to bring coordinates within the box
    XYZ = PBCincell(XYZ0,box,PBC)
    XYZout = PBCoutcell(XYZ, box, PBC);
    figure, hold on
    plot3(XYZ0(:,1), XYZ0(:,2), XYZ0(:,3), 'g.', 'MarkerSize', 10); % OUTCELL Original points in green
    plot3(XYZ(:,1), XYZ(:,2), XYZ(:,3), 'r.', 'MarkerSize', 10); % Original INCELL points in red
    plot3(XYZout(:,1), XYZout(:,2), XYZout(:,3), 'b.', 'MarkerSize', 10); % Adjusted points in blue
    xlabel('X'); ylabel('Y'); zlabel('Z'); title('Reunited Atoms in 3D');
    legend('True','Original', 'Adjusted');
    grid on; axis equal; view(3); hold off;
%}


[n, d] = size(XYZ);

% Validate inputs
if size(box, 2) ~= 2 || size(box, 1) ~= d
    error('Box dimensions must be a %dx2 vector', d);
end

if length(PBC) ~= d
    error('PBC must be a 1x%d logical vector', d);
end

% Calculate the center of the box
box_center = mean(box, 2)';

% Initialize output
XYZout = XYZ;
isReunited = false;

% Maximum iterations to avoid infinite loops
max_iters = 10;
iter = 0;

while iter < max_iters
    iter = iter + 1;
    XYZout_prev = XYZout;

    % Calculate the centroid of the points
    centroid = mean(XYZout, 1);

    % Adjust coordinates based on the centroid's location
    for i = 1:d
        if PBC(i)
            box_length = box(i, 2) - box(i, 1);
            for j = 1:n
                if abs(XYZout(j, i) - centroid(i)) > box_length / 2
                    if XYZout(j, i) > centroid(i)
                        XYZout(j, i) = XYZout(j, i) - box_length;
                    else
                        XYZout(j, i) = XYZout(j, i) + box_length;
                    end
                end
            end
        end
    end

    % Recalculate the centroid
    new_centroid = mean(XYZout, 1);

    % If the output is stable, break the loop
    if isequal(XYZout, XYZout_prev)
        break;
    end

    % Update the centroid
    centroid = new_centroid;
end

% Calculate the inertia before and after adjustment
initial_inertia = sum(sum((XYZ - mean(XYZ, 1)).^2));
adjusted_inertia = sum(sum((XYZout - mean(XYZout, 1)).^2));

% If the adjusted inertia is larger, revert to the original coordinates
if adjusted_inertia >= initial_inertia
    XYZout = XYZ;
    isReunited = false;
else
    isReunited = true;
end

if nargout > 1
    isReunitedout = isReunited;
end

end


% function [XYZout,isReunitedout] = PBCoutcell(XYZ, box, PBC)
% %PBCOUTCELL reunite atoms crossing PBC boundaries on one side based on the centroid's location
% %
% %   USAGE: XYZout = PBCoutcell(XYZ, box, PBC)
% %          [XYZout,isreunited] = PBCoutcell(...)
% %
% %   INPUTS:
% %          XYZ: nx2 or nx3 array coding for the coordinates of the n atoms in 2D or 3D
% %          box: 2x2 or 3x2 array coding for box dimensions
% %               the box spans along dimension i between box(i,1) and box(i,2)
% %          PBC: 1x2 or 1x3 boolean array
% %               PBC(i) is true if the dimension i is periodic
% %
% %   OUTPUT:
% %       XYZout: nx2 or nx3 array with coordinates adjusted to reunite atoms on one side of the boundaries
% %   isreunited: true if reunion has been applied
% 
% %   Example in 2D:
% %{
%     % Box limits
%     box = [0 10; 0 10];
%     % PBC in both dimensions
%     PBC = [true, true];
%     % Generate random points in a disk
%     n_particles = 10000;
%     radius = 0.35 * min(box(:,2) - box(:,1)) / 2;
%     theta = 2 * pi * rand(n_particles, 1);
%     r = radius * sqrt(rand(n_particles, 1));
%     center = (box(:,2) - box(:,1))' .* rand(1, 2) + box(:,1)';
%     XYZ0 = [center(1) + r .* cos(theta), center(2) + r .* sin(theta)];
%     % Adjust coordinates
%     XYZ = PBCincell(XYZ0,box,PBC);
%     XYZout = PBCoutcell(XYZ, box, PBC);
%     % Plotting
%     figure, hold on
%     plot(XYZ(:,1), XYZ(:,2), 'r.', 'MarkerSize', 10); % Original points in red
%     plot(XYZout(:,1), XYZout(:,2), 'b.', 'MarkerSize', 10); % Adjusted points in blue
%     xlabel('X'); ylabel('Y'); title('Reunited Atoms in 2D');
%     legend('Original', 'Adjusted');
%     grid on; axis equal; hold off;
% %}
% %
% %   Example in 3D:
% %{
%     % Box limits
%     box = [0 10; 0 10; 0 10];
%     % PBC in all dimensions
%     PBC = [true, true, true];
%     % Generate random points in a sphere
%     n_particles = 10000;
%     radius = 0.25 * min(box(:,2) - box(:,1)) / 2;
%     phi = 2 * pi * rand(n_particles, 1);
%     costheta = 2 * rand(n_particles, 1) - 1;
%     u = rand(n_particles, 1);
%     theta = acos(costheta);
%     r = radius * u.^(1/3);
%     center = (box(:,2) - box(:,1))' .* rand(1, 3) + box(:,1)';
%     XYZ0 = [center(1) + r .* sin(theta) .* cos(phi), ...
%            center(2) + r .* sin(theta) .* sin(phi), ...
%            center(3) + r .* cos(theta)];
%     % Adjust coordinates
%     XYZ = PBCincell(XYZ0,box,PBC)
%     XYZout = PBCoutcell(XYZ, box, PBC);
%     figure, hold on
%     plot3(XYZ0(:,1), XYZ0(:,2), XYZ0(:,3), 'g.', 'MarkerSize', 10); % OUTCELL Original points in green
%     plot3(XYZ(:,1), XYZ(:,2), XYZ(:,3), 'r.', 'MarkerSize', 10); % Original INCELL points in red
%     plot3(XYZout(:,1), XYZout(:,2), XYZout(:,3), 'b.', 'MarkerSize', 10); % Adjusted points in blue
%     xlabel('X'); ylabel('Y'); zlabel('Z'); title('Reunited Atoms in 3D');
%     legend('True','Original', 'Adjusted');
%     grid on; axis equal; view(3); hold off;
% %}
% 
% 
% % MS 3.0 | 2024-07-16 | INRAE\han.chen@inrae.fr, INRAE\Olivier.vitrac@agroparistech.fr | rev. 
% 
% 
% % Revision history
% 
% 
% % Number of atoms and dimensions
% [n, d] = size(XYZ);
% 
% % Validate inputs
% if size(box,2) ~= 2 || size(box,1) ~= d
%     error('Box dimensions must be a %dx2 vector', d);
% end
% 
% if length(PBC) ~= d
%     error('PBC must be a 1x%d logical vector', d);
% end
% 
% % Calculate the centroid of the object
% centroid = mean(XYZ, 1);
% 
% % Calculate the initial inertia
% initial_inertia = sum(sum((XYZ - centroid).^2));
% 
% % Initialize output
% XYZout = XYZ;
% 
% % Adjust coordinates based on the centroid's half-space
% for i = 1:d
%     if PBC(i)
%         box_length = box(i,2) - box(i,1);
%         half_box_length = box_length / 2;
%         centroid_half_space = (centroid(i) > (box(i,1) + half_box_length));
% 
%         % Check and adjust atoms' coordinates
%         for j = 1:n
%             if centroid_half_space
%                 % If centroid is in the upper half-space, move atoms in the lower half-space up
%                 if XYZ(j,i) < (box(i,1) + half_box_length)
%                     XYZout(j,i) = XYZout(j,i) + box_length;
%                 end
%             else
%                 % If centroid is in the lower half-space, move atoms in the upper half-space down
%                 if XYZ(j,i) > (box(i,1) + half_box_length)
%                     XYZout(j,i) = XYZout(j,i) - box_length;
%                 end
%             end
%         end
%     end
% end
% 
% % Calculate the adjusted inertia
% adjusted_inertia = sum(sum((XYZout - mean(XYZout, 1)).^2));
% 
% % If the adjusted inertia is larger, revert to the original coordinates
% if adjusted_inertia >= initial_inertia
%     XYZout = XYZ;
%     isReunited = false;
% else
%     isReunited = true;
% end
% 
% if nargout>1, isReunitedout = isReunited; end
% 
% end

function SetQuiverColor(q,currentColormap,varargin)
%--------------------------------------------------
% function SetQuiverColor(q,currentColormap)
%
% INPUT:
%   q = handle to quiver plot
%   currentColormap = e.g. jet;
% OPTIONAL INPUT ('Field',value):
%   'range' = [min,max]; % Range of the magnitude in the colorbar
%                          (used to possibly saturate or expand the color used compared to the vectors)
%   'mags' = magnitude; % Actual magnitude of the vectors
%
% Example:
%   [x,y] = meshgrid(-2:.2:2,-1:.15:1);
%   z = x .* exp(-x.^2 - y.^2);
%   [u,v,w] = surfnorm(x,y,z);
%   q = quiver3(x,y,z,u,v,w);
%   mag = 1+3.*rand(size(u));   % Creates number between 1 and 4
%   colormap(jet);
%   colorbar;
%   SetQuiverColor(q,jet,'mags',mag,'range',[-2 8]);  % Color range between -2 8 => all colors are not used
%   caxis([-2 8]);
%   set(gca,'Color','k');
%
%--------------------------------------------------
%   Authorship:
%     This code is heavily based from the answer by the user Suever on Stackoverflow forum
%     at: https://stackoverflow.com/questions/29632430/quiver3-arrow-color-corresponding-to-magnitude
%
%     I, Alexandre De Spiegeleer, only added minor changes to the original answer to have a bit more flexibility.
%--------------------------------------------------
%// Set default values
range = [];
mags = [];
%// Read the optional range value
if find(strcmp('range',varargin))
  range = varargin{ find(strcmp('range',varargin))+1 };
end
qU = q.UData(~isnan(q.UData));
qV = q.VData(~isnan(q.VData));
qW = q.WData(~isnan(q.WData));
%// Compute/read the magnitude of the vectors
if find(strcmp('mags',varargin))
  mags = varargin{ find(strcmp('mags',varargin))+1 };
  mags = mags(~isnan(mags)&~isnan(q.UData));  % This reshapes automatically
else
  mags = sqrt(sum(cat(2, qU, qV, ...
             reshape(qW, numel(qU), [])).^2, 2));
end
%// If range is auto, take range as the min and max of mags
if isstr(range) & strcmp(range,'auto')
  range = [min(mags) max(mags)];
end
%// Change value depending on the desired range
if ~isempty(range) & isnumeric(range) & numel(range)==2
  range = sort(range);
  mags(mags>range(2)) = range(2);
  mags(magsend
%// Now determine the color to make each arrow using a colormap
if ~isempty(range) & isnumeric(range) & numel(range)==2
  Edges = linspace(range(1),range(2),size(currentColormap, 1)+1);
  [~, ~, ind] = histcounts(mags, Edges);
else
  [~, ~, ind] = histcounts(mags, size(currentColormap, 1));
end
%// Now map this to a colormap to get RGB
cmap = uint8(ind2rgb(ind(:), currentColormap) * 255);
cmap(:,:,4) = 255;
cmap = permute(repmat(cmap, [1 3 1]), [2 1 3]);
%// Color data
cd_head = reshape(cmap(1:3,:,:), [], 4).';
cd_tail = reshape(cmap(1:2,:,:), [], 4).';
%// We repeat each color 3 times (using 1:3 below) because each arrow has 3 vertices
set(q.Head, 'ColorBinding', 'interpolated', 'ColorData', cd_head);
%// We repeat each color 2 times (using 1:2 below) because each tail has 2 vertices
set(q.Tail, 'ColorBinding', 'interpolated', 'ColorData', cd_tail);

function SetQuiverLength(q,mags,varargin)
%--------------------------------------------------
% function SetQuiverLength(q,mags)
%
%   Function that sets the length of the quiver
%   You can give a list of length (in x,y axis units), the function will rescale the vectors to the right length
%
% Input: q    = handle to quiver plot, can be quiver or quiver3
%        mags = Desired length of each vector in units of the x,y axis
%               If mags is a scalar, all the vector will have that length
% Optional inputs: given as ('variable',value)
%        'HeadLength' = single value for the length of the head in units of the xyz axis.
%                       It is applied to all the vectors
%        'HeadAngle' = angle between the two lines forming the head
%                      default=28.0724^\circ
%        'RotHead'   = Angle [deg] by which the head will be rotated around the vector axis.
%                      This allows to set the head in different planes
%
% NOTE: For some unknown reason, MATLAB does not always simply change the length of the vectors and requires a
%       pause statement towards the end.
%       Would your vectors not be the right size, increase the duration of the pause
%       (or even better, suggest a solution that does not require a pause)
%
% Example:
%     [x,y] = meshgrid(-2:.2:2,-1:.15:1);
%     z = x .* exp(-x.^2 - y.^2);
%     [u,v,w] = surfnorm(x,y,z);
%     q = quiver3(x,y,z,u,v,w); hold on; surf(x,y,z); hold off;
%     drawnow;                  % This is needed as, if the plot is not plotted, the VertexData for the quiver are not existent.
%     view(180,0);
%     mag = 0.1*ones(size(u));  % Length of the vectors : 0.1
%     SetQuiverLength(q,mag,'HeadLength',0.05,'HeadAngle',90);
%
%--------------------------------------------------
%   Authorship:
%     Function made by Alexandre De Spiegeleer. Feel free to use it.
%--------------------------------------------------
%// Set default values of varargin
HeadLength = [];
HeadAngle = [];
RotHead = [];
%// Read the optional inputs
if find(strcmp('HeadLength',varargin))
  HeadLength = varargin{ find(strcmp('HeadLength',varargin))+1 };
end
if find(strcmp('HeadAngle',varargin))
  HeadAngle = varargin{ find(strcmp('HeadAngle',varargin))+1 };
end
if find(strcmp('RotHead',varargin))
  RotHead = varargin{ find(strcmp('RotHead',varargin))+1 };
end
%// Start by removing the autoscale option
set(q,'AutoScale','Off');
%// Get the Head and Tail options
H = get(q.Head);
T = get(q.Tail);
%// Handle mags input
if isempty(mags)
  warning('No input was given for the length of the vectors. They are now all of length 1.');
  mags = ones(size(T.VertexData,2)/2,1);
elseif numel(mags) == 1
  mags = repmat(mags,size(T.VertexData,2)/2,1);
elseif size(mags) == size(q.XData)
  mags = reshape(mags,[],1);
elseif isrow(mags)
  mags = mags';
elseif numel(mags)~=size(T.VertexData,2)/2
  warning('Different number of magnitudes and quiver vectors!');
  return;
else
  warning('Bug when calling SetQuiverLength function!');
  return;
end
if find(mags<0)
  warning(['At least one of the length is requested to be negative. ' ...
          'This will swap the direction of the vector(s)!']);
end
%// The data for which there is no vector should be removed
%// as there is no Head or Tail data for those.
if numel(mags) == numel(q.UData)
  mags(isnan(q.UData)) = [];
end
%// Reshape the head and the tail (It is easier to think about it then but requires some repmat and permute)
%// The head has 3 vertices and the tail has 2.
Tail_ori = reshape(T.VertexData,size(T.VertexData,1),2,[]);
Head_ori = reshape(H.VertexData,size(H.VertexData,1),3,[]);
%// Measure original length of Head and Tail
Tail_length = squeeze(sqrt(sum(diff(Tail_ori,1,2).^2,1)));
Head_length = squeeze(sqrt(sum(diff(Head_ori(:,[1,2],:),1,2).^2,1)));
%// Head-Tail original ratio
Length_ratio = Head_length./Tail_length;
%// New length of head
if isempty(HeadLength)
  Head_mag = mags.*Length_ratio;
  Head_mag = permute(Head_mag(:,:,ones(size(H.VertexData,1),1)),[3 2 1]);
elseif ~isempty(HeadLength)
  Head_mag = repmat(HeadLength,[size(H.VertexData,1) 1 size(Head_ori,3)]);
end
%// Direction tail
Tail_dir = diff(Tail_ori,1,2)./permute(Tail_length(:,:,ones(size(T.VertexData,1),1)),[3 2 1]);
%// Directions of head
Head_dir_a = diff(Head_ori(:,[2,1],:),1,2)./permute(Head_length(:,:,ones(size(H.VertexData,1),1)),[3 2 1]);
Head_dir_b = diff(Head_ori(:,[2,3],:),1,2)./permute(Head_length(:,:,ones(size(H.VertexData,1),1)),[3 2 1]);
%// Set new HeadAngle by use of Rodrigues' rotation formula
if ~isempty(HeadAngle)
  % rotation axis:
  k = cross(Head_dir_b,Head_dir_a,1)./sqrt(sum(cross(Head_dir_b,Head_dir_a,1).^2,1));
  % Original angle:
  alpha = acosd( dot(Head_dir_a,Head_dir_b,1) );
  % Angle of rotation:
  theta = (HeadAngle-alpha)/2;
  % Rotation
  ct = repmat(cosd(theta),size(H.VertexData,1),1,1);
  st = repmat(sind(theta),size(H.VertexData,1),1,1);
  Head_dir_a_r = Head_dir_a .* ct + ...
                cross(k,Head_dir_a,1) .* st + ...
                k .* repmat(dot(k,Head_dir_a,1),size(H.VertexData,1),1,1) .* (1-ct);
  ct = repmat(cosd(-theta),size(H.VertexData,1),1,1);
  st = repmat(sind(-theta),size(H.VertexData,1),1,1);
  Head_dir_b_r = Head_dir_b .* ct + ...
                cross(k,Head_dir_b,1) .* st + ...
                k .* repmat(dot(k,Head_dir_b,1),size(H.VertexData,1),1,1) .* (1-ct);
  Head_dir_a = Head_dir_a_r;
  Head_dir_b = Head_dir_b_r;
end
%// Set new RotHead by use of Rodrigues' rotation formula
if ~isempty(RotHead)
  % rotation axis:
  k = Tail_dir;
  % Angle of rotation:
  theta = RotHead;
  % Rotation
  ct = repmat(cosd(theta),size(H.VertexData,1),1,1);
  st = repmat(sind(theta),size(H.VertexData,1),1,1);
  Head_dir_a_r = Head_dir_a .* ct + ...
                cross(k,Head_dir_a,1) .* st + ...
                k .* repmat(dot(k,Head_dir_a,1),size(H.VertexData,1),1,1) .* (1-ct);
  Head_dir_b_r = Head_dir_b .* ct + ...
                cross(k,Head_dir_b,1) .* st + ...
                k .* repmat(dot(k,Head_dir_b,1),size(H.VertexData,1),1,1) .* (1-ct);
  Head_dir_a = Head_dir_a_r;
  Head_dir_b = Head_dir_b_r;
end
%// New Tail End = start of tail + magnitude*normalized direction
TailVertex = Tail_ori;
TailVertex(:,2,:) = TailVertex(:,1,:) +  ...
            permute(mags(:,:,ones(size(T.VertexData,1),1)),[3 2 1]) .*  Tail_dir;
%// Middle point of Head is same as end of Tail
HeadVertex = Head_ori;
HeadVertex(:,2,:) = TailVertex(:,2,:);
%// Head vector a
HeadVertex(:,1,:) = HeadVertex(:,2,:) + Head_mag .* Head_dir_a;
%// Head vector b
HeadVertex(:,3,:) = HeadVertex(:,2,:) + Head_mag .* Head_dir_b;
%// If the vector is originally of size 0, the vectors are now NaN.
%// Change those back to have just a simple "single point"
Idx_NaN = find(isnan(squeeze(TailVertex(1,end,:))));
TailVertex(:,end,Idx_NaN) = TailVertex(:,1,Idx_NaN);
HeadVertex(:,:,Idx_NaN) = repmat(TailVertex(:,1,Idx_NaN),1,3,1);
%// Reshape the data
HeadVertex = reshape(HeadVertex,size(H.VertexData,1),[]);
TailVertex = reshape(TailVertex,size(T.VertexData,1),[]);
%// Don't ask me about this line ...
%// Matlab sucks and does not do the change graphically if I don't have a pause or a keyboard ...
pause(0.0102)
%// Set the data to the quiver properties
set(q.Head,'VertexData',HeadVertex);
set(q.Tail,'VertexData',TailVertex);

% Second template to retrieve Billy's paper 2 simulation data 
% rev. 2024/04/29

% 2024/04/29 retrive 3D data around the top of the pillar

% SUMMARY

% This MATLAB script is a comprehensive framework for analyzing fluid dynamics simulations, specifically focusing on the distribution and movement of particles or beads in a fluid environment. Key functionalities include:
% 
% 1. Environment Setup:
%   Initializes the simulation environment by clearing variables, setting up output folders, and defining file paths to simulation data, with adjustments for periodic boundary conditions (PBC).
% 2. Data Retrieval:
%   Loads simulation data from specified file paths, handling different configurations and viscosity models.

%% Definitions (it is a script accepting ONE variable and FLAGS)
%
%   List of of variables
%           tframe <-- use this variable a in for-loop or choose a particular frame before calling this script
%       tframelist (not used)
%
%   List of available FLAGS
%       RESETPREFETCH forces all prefetch files to be regenerated in true (default=false)
%              PLOTON enables to plot results (default=true)
%             PRINTON prints figures as PNG images for control (in outputfolder) (default=false)
%              SAVEON saves the results R0 (original), R1 (informed) (default=true)
%           OVERWRITE enables already saved results to overwritte (default=false)

% close, delete everything except variables and FLAGS
clc
close all
clearvars -except tframe tframelist RESETPREFETCH PLOTON PRINTON SAVEON OVERWRITE
t0_ = clock;

% check folders
outputfolder = fullfile(pwd,'preproduction');
savefolder = fullfile(pwd,'results');
prefetchfolder = fullfile(pwd,'prefetch');
if ~exist(outputfolder,'dir'), mkdir(outputfolder); end
if ~exist(prefetchfolder,'dir'), mkdir(prefetchfolder); end
if ~exist(savefolder,'dir'), mkdir(savefolder); end

% Assign default values if needed
if ~exist('RESETPREFETCH','var'), RESETPREFETCH = false; end
if ~exist('PLOTON','var'), PLOTON = true; end
if ~exist('PRINTON','var'), PRINTON = false; end
if ~exist('SAVEON','var'), SAVEON = true; end
if ~exist('OVERWRITE','var'), OVERWRITE = false; end

% Anonymous functions
prefetchvar = @(varargin) fullfile(prefetchfolder,sprintf('t%0.4f_%s.mat',tframe,varargin{1}));
isprefetch = @(varargin) exist(prefetchvar(varargin{1}),'file') && ~RESETPREFETCH;
dispsection = @(s) dispf('\n%s\ntframe=%0.4g s \t[  %s  ]   elapsed time: %4g s\n%s',repmat('*',1,120),tframe,regexprep(upper(s),'.','$0 '),etime(clock,t0_),repmat('*',1,120)); %#ok
fighandle = @(id) formatfig(figure,'figname',sprintf('t%0.3g_%s',tframe,id));
printhandle = @(hfig) print_png(300,fullfile(outputfolder,[get(hfig,'filename') '.png']),'','',0,0,0);

% results saved in two variables to avoid any confusion
R0 = struct([]); % reference data
R1 = struct([]);  % informed ones

%% path and metadata
dispsection('INITIALIZATION')
originalroot = '/media/olivi/T7 Shield/Thomazo_V2';
if exist(originalroot,'dir')
    root = originalroot;
    rootlocal = fullfile(pwd,'smalldumps');
    copymode = true;
else
    root = fullfile(pwd,'smalldumps');
    copymode = false;
end

simfolder = ...
    struct(...
    'A1',struct('artificial',...
'Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz',...
    'Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle.tar.gz' ...
                ),...
    'A2',struct('artificial',...
'./Production/numericalViscosimeter_reference_ulsphBulk_hertzBoundary/dump.ulsphBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_2.tar.gz' ...
    ),...
    'B1',struct('Morris',...
'./Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft.tar.gz' ...
    ),...
    'B2',struct('Morris',...
'Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_1.tar.gz' ...
    ),...
    'B3',struct('Morris',...
'/Production/numericalViscosimeter_reference_morrisBulk_hertzBoundary/dump.morrisBulk_hertzBoundary_referenceParameterExponent+1_with1SuspendedParticle_soft_2_3.tar.gz' ...
    ) ...
    );

% selection (not change it if you do not have the full dataset/hard disk attached to your system)
config = 'A1';
viscosity = 'Morris';
sourcefolder= fullfile(root,rootdir(simfolder.(config).(viscosity)));
sourcefile = regexprep(lastdir(simfolder.(config).(viscosity)),'.tar.gz$','');
dumpfile = fullfile(sourcefolder,sourcefile);
dispf('config: %s | viscosity: %s | source: %s',config,viscosity,dumpfile)

%% extract information
dispsection('OVERVIEW')
X0 = lamdumpread2(dumpfile); % first frame
natoms = X0.NUMBER;
timesteps = X0.TIMESTEPS;
X1 = lamdumpread2(dumpfile,'usesplit',[],timesteps(2));
dt = (X1.TIME-X0.TIME)/(timesteps(2)-timesteps(1)); % integration time step
times = double(timesteps * dt); % in seconds 
atomtypes = unique(X0.ATOMS.type);
ntimesteps = length(timesteps);
T = X0.ATOMS.type;
natomspertype = arrayfun(@(t) length(find(T==t)),atomtypes);
[~,ind] = sort(natomspertype,'descend');
% Thomazo simulation details
fluidtype  = ind(1);
pillartype = ind(2);
walltype   = ind(3);
spheretype = ind(4);
coords = {'z','x','y'}; % to match Thomazo's movies
vcoords = cellfun(@(c) sprintf('v%s',c),coords,'UniformOutput',false);
icoords = cellfun(@(c) find(ismember({'x','y','z'},c)),coords); %<- use this index for BOX
% Simulation parameters
% Billy choose a reference density of 900 kg/m3 for a physical density of 1000 kg/m3
% Viscosity: 0.13 Pa.s
mbead = 4.38e-12; % kg
rho = 1000; % kg / m3 (density of the fluid)
Vbead = mbead/rho;
dispf('SUMMARY: natoms: %d | dt: %0.3g s | rho: %0.4g',natoms,dt,rho)

%% selective copy of PREFETCH files (if possible)
if copymode
    dispsection('COPY')
    myprefetchfile = @(itime) sprintf('%s%09d.mat','TIMESTEP_',itime);
    myprefetchfolder = @(d) fullfile(d,sprintf('PREFETCH_%s',lastdir(dumpfile)));
    destinationfolder = fullfile(rootlocal,rootdir(simfolder.(config).(viscosity)));
    sourcefolderPREFETCH = myprefetchfolder(sourcefolder);
    destinationfolderPREFETCH = myprefetchfolder(destinationfolder);
    % Choose the frames needed here
    tcopy = 0.0:0.01:1.2;
    % files to copy
    tfile = arrayfun(@(t) myprefetchfile(t), timesteps(unique(nearestpoint(tcopy,times))),'UniformOutput',false);
    oksource = all(cellfun(@(f) exist(fullfile(sourcefolderPREFETCH,f),'file'),tfile));
    if ~oksource, error('the source folder is corrupted, please check'), end
    existingfiles = cellfun(@(f) exist(fullfile(destinationfolderPREFETCH,f),'file'),tfile);
    dispf('Number of files to copy: %d (%d already available)',length(find(~existingfiles)),length(find(existingfiles)))
    copysuccess = cellfun(@(f) copyfile(fullfile(sourcefolderPREFETCH,f),fullfile(destinationfolderPREFETCH,f)),tfile(~existingfiles));
    dispf('%d of %d files have been copied',length(find(copysuccess)),length(copysuccess));
end

%% Estimate bead size from the first frame
% first estimate assuming that the bead is a cube
dispsection('BEAD SIZE')
fluidxyz0 = X0.ATOMS{T==fluidtype,coords};
boxdims = X0.BOX(:,2) - X0.BOX(:,1);
Vbead_guess = prod(boxdims)/natoms;
rbead_guess = (3/(4*pi)*Vbead_guess)^(1/3);
cutoff = 3*rbead_guess;
if isprefetch('verletList')
    load(prefetchvar('verletList'))
else
    [verletList,cutoff,dmin,config,dist] = buildVerletList(fluidxyz0,cutoff);
    save(prefetchvar('verletList'),'verletList','cutoff','dmin','config','dist')
end
rbead = dmin/2;
s = 2*rbead; % separation distance
h = 2*s;     % smoothing length
dispf('SUMMARY: s: %0.4g m | h: %0.4g m',s,h)
%% load the frame closest to simulation time: tframe
% with the mini dataset, are available:
% 0.30s 0.40s 0.45s 0.50s 0.55s 0.60s 0.65s 0.70s 0.75s 0.80s 0.85s 0.90s 0.95s 1.00s 1.05s 1.10s 
% tframelist = [0.3 0.4 0.45:0.05:1.10]; % verysmalldumps
tframelist = 0.0:0.01:1.2; % updated time frames
if ~exist('tframe','var')
    tframe = 0.85; %0.55; % s <-------------------- select time here
else
    tframe = tframelist(nearestpoint(tframe,tframelist)); % restrict to existing tframes
end
iframe = nearestpoint(tframe,times); % closest index
Xframe = lamdumpread2(dumpfile,'usesplit',[],timesteps(iframe));
Xframe.ATOMS.isfluid = Xframe.ATOMS.type==fluidtype;
Xframe.ATOMS.ispillar = Xframe.ATOMS.type==pillartype;
Xframe.ATOMS.issphere = Xframe.ATOMS.type==spheretype;
Xframe.ATOMS.issolid = Xframe.ATOMS.type==spheretype | Xframe.ATOMS.type==pillartype;
fluidxyz = Xframe.ATOMS{Xframe.ATOMS.isfluid,coords};
fluidid = X0.ATOMS{Xframe.ATOMS.isfluid,'id'};
pillarxyz = Xframe.ATOMS{Xframe.ATOMS.ispillar,coords};
pillarid = X0.ATOMS{Xframe.ATOMS.ispillar,'id'};
spherexyz = Xframe.ATOMS{Xframe.ATOMS.issphere,coords};
sphereid = X0.ATOMS{Xframe.ATOMS.issphere,'id'};
solidxyz = Xframe.ATOMS{Xframe.ATOMS.issolid,coords};
solidid = X0.ATOMS{Xframe.ATOMS.issolid,'id'};
ztop = max(pillarxyz(:,3)); % pillar top

% Definitions based on actual tframe
dispsection = @(s) dispf('\n%s\ntframe=%0.4g s \t[  %s  ]   elapsed time: %4g s\n%s',repmat('*',1,120),tframe,regexprep(upper(s),'.','$0 '),etime(clock,t0_),repmat('*',1,120)); %#ok
prefetchvar = @(varargin) fullfile(prefetchfolder,sprintf('t%0.4f_%s.mat',tframe,varargin{1}));
isprefetch = @(varargin) exist(prefetchvar(varargin{1}),'file') && ~RESETPREFETCH;
savefile = @() fullfile(savefolder,sprintf('Rt.%0.4f.mat',tframe));


%% Interpolate velocity field at z = ztop
dispsection('REFERENCE VELOCITY FIELD')
% full box (note that atoms may be outside of this box)
box = Xframe.BOX(icoords,:); % note that the order is given by coords, here {'z'}    {'x'}    {'y'}
boxsize = diff(box,1,2);
% fluidbox (box for atoms to consider)
xmin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{1}});
xmax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{1}});
ymin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{2}});
ymax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{2}});
zmin = min(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{3}});
zmax = max(Xframe.ATOMS{Xframe.ATOMS.isfluid,coords{3}});
fluidbox = [xmin xmax;ymin ymax;zmin zmax];
% restrict interpolation to the viewbox
viewbox = viewbox3d; %fluidbox; viewbox(3,:) = [ztop-2*h ztop+2*h];
viewboxsize = diff(viewbox,1,2);
insideviewbox = true(height(Xframe.ATOMS),1);
for icoord = 1:3
    insideviewbox = insideviewbox ...
        & Xframe.ATOMS{:,coords{icoord}}>=viewbox(icoord,1) ...
        & Xframe.ATOMS{:,coords{icoord}}<=viewbox(icoord,2);
end
XYZall  = Xframe.ATOMS{Xframe.ATOMS.isfluid,coords};  % fluid kernel centers
vXYZall = Xframe.ATOMS{Xframe.ATOMS.isfluid,vcoords}; % velocity of fluid kernel centers
XYZ  = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.isfluid,coords};  % fluid kernel centers
vXYZ = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.isfluid,vcoords}; % velocity of fluid kernel centers
XYZp = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.ispillar,coords};  % solid kernel centers
XYZs = Xframe.ATOMS{insideviewbox & Xframe.ATOMS.issphere,coords}; 
rhobeadXYZall = Xframe.ATOMS.c_rho_smd(Xframe.ATOMS.isfluid); % volume of the bead
rhobeadXYZ = Xframe.ATOMS.c_rho_smd(insideviewbox & Xframe.ATOMS.isfluid); % volume of the bead
VbeadXYZall = mbead./rhobeadXYZall;
VbeadXYZ = mbead./rhobeadXYZ;


% Plot
if PLOTON
    figure, hold on
    plot3D(XYZ,'bo')
    plot3D(XYZs,'ro')
    plot3D(XYZp,'go')
    view(3)
end

% Add bead along streamlines (considering quasi steady state)
% rev. 2024/03/12
% 2024/03/12
%%
function [x,y,Vl,l] = add_bead(s,rbead,dt)
nmax = ceil(s.l(end)/(2*rbead));  % maximum number of bead along the streamline
[x,y,l,Vl] = deal(nan(nmax,1));   % creat container
l(1) = rbead; % put first bead
cn = 1; % current number of bead
while l(1)<(s.l(end)-rbead)
    x = interp1(s.l,s.x,l);
    y = interp1(s.l,s.y,l);
    Vl = interp1(s.l,s.Vl,l);
    l = l + Vl*dt; % update the positions of beads
    if l(cn)>3*rbead
        l(cn+1) = rbead;
        cn = cn+1;
    end
end
x = interp1(s.l,s.x,l);
y = interp1(s.l,s.y,l);
Vl = interp1(s.l,s.Vl,l);
end

function [h,yy,zz] = arrow(varargin)
% ARROW  Draw a line with an arrowhead.
%
%  ARROW(Start,Stop) draws a line with an arrow from Start to Stop (points
%        should be vectors of length 2 or 3, or matrices with 2 or 3
%        columns), and returns the graphics handle of the arrow(s).
%
%  ARROW uses the mouse (click-drag) to create an arrow.
%
%  ARROW DEMO & ARROW DEMO2 show 3-D & 2-D demos of the capabilities of ARROW.
%
%  ARROW may be called with a normal argument list or a property-based list.
%        ARROW(Start,Stop,Length,BaseAngle,TipAngle,Width,Page,CrossDir) is
%        the full normal argument list, where all but the Start and Stop
%        points are optional.  If you need to specify a later argument (e.g.,
%        Page) but want default values of earlier ones (e.g., TipAngle),
%        pass an empty matrix for the earlier ones (e.g., TipAngle=[]).
%
%  ARROW('Property1',PropVal1,'Property2',PropVal2,...) creates arrows with the
%        given properties, using default values for any unspecified or given as
%        'default' or NaN.  Some properties used for line and patch objects are
%        used in a modified fashion, others are passed directly to LINE, PATCH,
%        or SET.  For a detailed properties explanation, call ARROW PROPERTIES.
%
%        Start         The starting points.                     B
%        Stop          The end points.                         /|\           ^
%        Length        Length of the arrowhead in pixels.     /|||\          |
%        BaseAngle     Base angle in degrees (ADE).          //|||\\        L|
%        TipAngle      Tip angle in degrees (ABC).          ///|||\\\       e|
%        Width         Width of the base in pixels.        ////|||\\\\      n|
%        Page          Use hardcopy proportions.          /////|D|\\\\\     g|
%        CrossDir      Vector || to arrowhead plane.     ////  |||  \\\\    t|
%        NormalDir     Vector out of arrowhead plane.   ///    |||    \\\   h|
%        Ends          Which end has an arrowhead.     //<----->||      \\   |
%        ObjectHandles Vector of handles to update.   /   base |||        \  V
%                                                    E    angle||<-------->C
%  ARROW(H,'Prop1',PropVal1,...), where H is a                 |||tipangle
%        vector of handles to previously-created arrows        |||
%        and/or line objects, will update the previously-      |||
%        created arrows according to the current view       -->|A|<-- width
%        and any specified properties, and will convert
%        two-point line objects to corresponding arrows.  ARROW(H) will update
%        the arrows if the current view has changed.  Root, figure, or axes
%        handles included in H are replaced by all descendant Arrow objects.
%
%  A property list can follow any specified normal argument list, e.g.,
%  ARROW([1 2 3],[0 0 0],36,'BaseAngle',60) creates an arrow from (1,2,3) to
%  the origin, with an arrowhead of length 36 pixels and 60-degree base angle.
%
%  Normally, an ARROW is a PATCH object, so any valid PATCH property/value pairs
%  can be passed, e.g., ARROW(Start,Stop,'EdgeColor','r','FaceColor','g').
%  ARROW will use LINE objects when requested by ARROW(...,'Type','line') or,
%  using LINE property/value pairs, ARROW(Start,Stop,'Type','line','Color','b').
%
%  The basic arguments or properties can generally be vectorized to create
%  multiple arrows with the same call.  This is done by passing a property
%  with one row per arrow, or, if all arrows are to have the same property
%  value, just one row may be specified.
%
%  You may want to execute AXIS(AXIS) before calling ARROW so it doesn't change
%  the axes on you; ARROW determines the sizes of arrow components BEFORE the
%  arrow is plotted, so if ARROW changes axis limits, arrows may be malformed.
%
%  This version of ARROW uses features of MATLAB 6.x and is incompatible with
%  earlier MATLAB versions (ARROW for MATLAB 4.2c is available separately);
%  some problems with perspective plots still exist.

% Copyright (c)1995-2016, Dr. Erik A. Johnson , 5/25/2016
% http://www.usc.edu/civil_eng/johnsone/

% Revision history:
%    5/25/16  EAJ  Add documentation of 'Type','line'
%                  Add documentation of how to set color
%                  Add 'Color' property (which sets both 'EdgeColor' and 'FaceColor' for patch objects)
%    5/24/16  EAJ  Remove 'EraseMode' in HG2
%    7/16/14  EAJ  R2014b HandleGraphics2 compatibility
%    7/14/14  EAJ  5/20/13 patch extension didn't work right in HG2
%                    so break the arrow along its length instead
%    5/20/13  EAJ  Extend patch line one more segment so EPS/PDF printed versions
%                    have nice rounded tips when the LineWidth is wider
%    2/06/13  EAJ  Add ShortenLength property to shorten length if arrow is short
%    1/24/13  EAJ  Remove some old comments.
%    5/20/09  EAJ  Fix view direction in (3D) demo.
%    6/26/08  EAJ  Replace eval('trycmd','catchcmd') with try, trycmd; catch,
%                    catchcmd; end; -- break's MATLAB 5 compatibility.
%    8/26/03  EAJ  Eliminate OpenGL attempted fix since it didn't fix anyway.
%   11/15/02  EAJ  Accomodate how MATLAB 6.5 handles NaN and logicals
%    7/28/02  EAJ  Tried (but failed) work-around for MATLAB 6.x / OpenGL bug
%                    if zero 'Width' or not double-ended
%   11/10/99  EAJ  Add logical() to eliminate zero index problem in MATLAB 5.3.
%   11/10/99  EAJ  Corrected warning if axis limits changed on multiple axes.
%   11/10/99  EAJ  Update e-mail address.
%    2/10/99  EAJ  Some documentation updating.
%    2/24/98  EAJ  Fixed bug if Start~=Stop but both colinear with viewpoint.
%    8/14/97  EAJ  Added workaround for MATLAB 5.1 scalar logical transpose bug.
%    7/21/97  EAJ  Fixed a few misc bugs.
%    7/14/97  EAJ  Make arrow([],'Prop',...) do nothing (no old handles)
%    6/23/97  EAJ  MATLAB 5 compatible version, release.
%    5/27/97  EAJ  Added Line Arrows back in.  Corrected a few bugs.
%    5/26/97  EAJ  Changed missing Start/Stop to mouse-selected arrows.
%    5/19/97  EAJ  MATLAB 5 compatible version, beta.
%    4/13/97  EAJ  MATLAB 5 compatible version, alpha.
%    1/31/97  EAJ  Fixed bug with multiple arrows and unspecified Z coords.
%   12/05/96  EAJ  Fixed one more bug with log plots and NormalDir specified
%   10/24/96  EAJ  Fixed bug with log plots and NormalDir specified
%   11/13/95  EAJ  Corrected handling for 'reverse' axis directions
%   10/06/95  EAJ  Corrected occasional conflict with SUBPLOT
%    4/24/95  EAJ  A major rewrite.
%    Fall 94  EAJ  Original code.

% Things to be done:
%  - in the arrow_clicks section, prompt by printing to the screen so that
%    the user knows what's going on; also make sure the figure is brought
%    to the front.
%  - segment parsing, computing, and plotting into separate subfunctions
%  - change computing from Xform to Camera paradigms
%     + this will help especially with 3-D perspective plots
%     + if the WarpToFill section works right, remove warning code
%     + when perpsective works properly, remove perspective warning code
%  - add cell property values and struct property name/values (like get/set)
%  - get rid of NaN as the "default" data label
%     + perhaps change userdata to a struct and don't include (or leave
%       empty) the values specified as default; or use a cell containing
%       an empty matrix for a default value
%  - add functionality of GET to retrieve current values of ARROW properties
% 
% New list of things to be done:
%  - rewrite as a graphics or class object that updates itself in real time
%    (but have a 'Static' or 'DoNotUpdate' property to avoid updating)

% Permission is granted to distribute ARROW with the toolboxes for the book
% "Solving Solid Mechanics Problems with MATLAB 5", by F. Golnaraghi et al.
% (Prentice Hall, 1999).

% Permission is granted to Dr. Josef Bigun to distribute ARROW with his
% software to reproduce the figures in his image analysis text.

% global variable initialization
persistent ARROW_PERSP_WARN ARROW_STRETCH_WARN ARROW_AXLIMITS ARROW_AX
if isempty(ARROW_PERSP_WARN  ), ARROW_PERSP_WARN  =1; end;
if isempty(ARROW_STRETCH_WARN), ARROW_STRETCH_WARN=1; end;

% Handle callbacks
if (nargin>0 & isstr(varargin{1}) & strcmp(lower(varargin{1}),'callback')),
	arrow_callback(varargin{2:end}); return;
end;

% Are we doing the demo?
c = sprintf('\n');
if (nargin==1 & isstr(varargin{1})),
	arg1 = lower(varargin{1});
	if strncmp(arg1,'prop',4), arrow_props;
	elseif strncmp(arg1,'demo',4)
		clf reset
		demo_info = arrow_demo;
		if ~strncmp(arg1,'demo2',5),
			hh=arrow_demo3(demo_info);
		else,
			hh=arrow_demo2(demo_info);
		end;
		if (nargout>=1), h=hh; end;
	elseif strncmp(arg1,'fixlimits',3),
		arrow_fixlimits(ARROW_AX,ARROW_AXLIMITS);
		ARROW_AXLIMITS=[]; ARROW_AX=[];
	elseif strncmp(arg1,'help',4),
		disp(help(mfilename));
	else,
		error([upper(mfilename) ' got an unknown single-argument string ''' deblank(arg1) '''.']);
	end;
	return;
end;

% Check # of arguments
if (nargout>3), error([upper(mfilename) ' produces at most 3 output arguments.']); end;

% find first property number
firstprop = nargin+1;
for k=1:length(varargin), if ~isnumeric(varargin{k}) && ~all(ishandle(varargin{k})), firstprop=k; break; end; end; %eaj 5/24/16   for k=1:length(varargin), if ~isnumeric(varargin{k}), firstprop=k; break; end; end;
lastnumeric = firstprop-1;

% check property list
if (firstprop<=nargin),
	for k=firstprop:2:nargin,
		curarg = varargin{k};
		if ~isstr(curarg) | sum(size(curarg)>1)>1,
			error([upper(mfilename) ' requires that a property name be a single string.']);
		end;
	end;
	if (rem(nargin-firstprop,2)~=1),
		error([upper(mfilename) ' requires that the property ''' ...
		       varargin{nargin} ''' be paired with a property value.']);
	end;
end;

% default output
if (nargout>0), h=[]; end;
if (nargout>1), yy=[]; end;
if (nargout>2), zz=[]; end;

% set values to empty matrices
start      = [];
stop       = [];
len        = [];
baseangle  = [];
tipangle   = [];
wid        = [];
page       = [];
crossdir   = [];
ends       = [];
shorten    = [];
ax         = [];
oldh       = [];
ispatch    = [];
defstart      = [NaN NaN NaN];
defstop       = [NaN NaN NaN];
deflen        = 16;
defbaseangle  = 90;
deftipangle   = 16;
defwid        = 0;
defpage       = 0;
defcrossdir   = [NaN NaN NaN];
defends       = 1;
defshorten    = 0;
defoldh       = [];
defispatch    = 1;

% The 'Tag' we'll put on our arrows
ArrowTag = 'Arrow';

% check for oldstyle arguments
if (firstprop==2),
	% assume arg1 is a set of handles
	oldh = varargin{1}(:);
	if isempty(oldh), return; end;
elseif (firstprop>9),
	error([upper(mfilename) ' takes at most 8 non-property arguments.']);
elseif (firstprop>2),
	{start,stop,len,baseangle,tipangle,wid,page,crossdir};
	args = [varargin(1:firstprop-1) cell(1,length(ans)-(firstprop-1))];
	[start,stop,len,baseangle,tipangle,wid,page,crossdir] = deal(args{:});
end;

% parse property pairs
extraprops={};
for k=firstprop:2:nargin,
	prop = varargin{k};
	val  = varargin{k+1};
	prop = [lower(prop(:)') '      '];
	if     strncmp(prop,'start'  ,5),   start      = val;
	elseif strncmp(prop,'stop'   ,4),   stop       = val;
	elseif strncmp(prop,'len'    ,3),   len        = val(:);
	elseif strncmp(prop,'base'   ,4),   baseangle  = val(:);
	elseif strncmp(prop,'tip'    ,3),   tipangle   = val(:);
	elseif strncmp(prop,'wid'    ,3),   wid        = val(:);
	elseif strncmp(prop,'page'   ,4),   page       = val;
	elseif strncmp(prop,'cross'  ,5),   crossdir   = val;
	elseif strncmp(prop,'norm'   ,4),   if (isstr(val)), crossdir=val; else, crossdir=val*sqrt(-1); end;
	elseif strncmp(prop,'end'    ,3),   ends       = val;
	elseif strncmp(prop,'shorten',5),   shorten    = val;
	elseif strncmp(prop,'object' ,6),   oldh       = val(:);
	elseif strncmp(prop,'handle' ,6),   oldh       = val(:);
	elseif strncmp(prop,'type'   ,4),   ispatch    = val;
	elseif strncmp(prop,'userd'  ,5),   %ignore it
	else,
		% make sure it is a valid patch or line property
		try
			get(0,['DefaultPatch' varargin{k}]);
		catch
			errstr = lasterr;
			try
				get(0,['DefaultLine' varargin{k}]);
			catch
				errstr(1:max(find(errstr==char(13)|errstr==char(10)))) = '';
				error([upper(mfilename) ' got ' errstr]);
			end
		end;
		extraprops={extraprops{:},varargin{k},val};
	end;
end;

% Check if we got 'default' values
start     = arrow_defcheck(start    ,defstart    ,'Start'        );
stop      = arrow_defcheck(stop     ,defstop     ,'Stop'         );
len       = arrow_defcheck(len      ,deflen      ,'Length'       );
baseangle = arrow_defcheck(baseangle,defbaseangle,'BaseAngle'    );
tipangle  = arrow_defcheck(tipangle ,deftipangle ,'TipAngle'     );
wid       = arrow_defcheck(wid      ,defwid      ,'Width'        );
crossdir  = arrow_defcheck(crossdir ,defcrossdir ,'CrossDir'     );
page      = arrow_defcheck(page     ,defpage     ,'Page'         );
ends      = arrow_defcheck(ends     ,defends     ,''             );
shorten   = arrow_defcheck(shorten  ,defshorten  ,''             );
oldh      = arrow_defcheck(oldh     ,[]          ,'ObjectHandles');
ispatch   = arrow_defcheck(ispatch  ,defispatch  ,''             );

% check transpose on arguments
[m,n]=size(start   );   if any(m==[2 3])&(n==1|n>3),   start    = start';      end;
[m,n]=size(stop    );   if any(m==[2 3])&(n==1|n>3),   stop     = stop';       end;
[m,n]=size(crossdir);   if any(m==[2 3])&(n==1|n>3),   crossdir = crossdir';   end;

% convert strings to numbers
if ~isempty(ends) & isstr(ends),
	endsorig = ends;
	[m,n] = size(ends);
	col = lower([ends(:,1:min(3,n)) ones(m,max(0,3-n))*' ']);
	ends = NaN*ones(m,1);
	oo = ones(1,m);
	ii=find(all(col'==['non']'*oo)'); if ~isempty(ii), ends(ii)=ones(length(ii),1)*0; end;
	ii=find(all(col'==['sto']'*oo)'); if ~isempty(ii), ends(ii)=ones(length(ii),1)*1; end;
	ii=find(all(col'==['sta']'*oo)'); if ~isempty(ii), ends(ii)=ones(length(ii),1)*2; end;
	ii=find(all(col'==['bot']'*oo)'); if ~isempty(ii), ends(ii)=ones(length(ii),1)*3; end;
	if any(isnan(ends)),
		ii = min(find(isnan(ends)));
		error([upper(mfilename) ' does not recognize ''' deblank(endsorig(ii,:)) ''' as a valid ''Ends'' value.']);
	end;
else,
	ends = ends(:);
end;
if ~isempty(ispatch) & isstr(ispatch),
	col = lower(ispatch(:,1));
	patchchar='p'; linechar='l'; defchar=' ';
	mask = col~=patchchar & col~=linechar & col~=defchar;
	if any(mask),
		error([upper(mfilename) ' does not recognize ''' deblank(ispatch(min(find(mask)),:)) ''' as a valid ''Type'' value.']);
	end;
	ispatch = (col==patchchar)*1 + (col==linechar)*0 + (col==defchar)*defispatch;
else,
	ispatch = ispatch(:);
end;
oldh = oldh(:);

% check object handles
if ~all(ishandle(oldh)), error([upper(mfilename) ' got invalid object handles.']); end;

% expand root, figure, and axes handles
if ~isempty(oldh),
	ohtype = get(oldh,'Type');
	mask = strcmp(ohtype,'root') | strcmp(ohtype,'figure') | strcmp(ohtype,'axes');
	if any(mask),
		oldh = num2cell(oldh);
		for ii=find(mask)',
			oldh(ii) = {findobj(oldh{ii},'Tag',ArrowTag)};
		end;
		oldh = cat(1,oldh{:});
		if isempty(oldh), return; end; % no arrows to modify, so just leave
	end;
end;

% largest argument length
[mstart,junk]=size(start); [mstop,junk]=size(stop); [mcrossdir,junk]=size(crossdir);
argsizes = [length(oldh) mstart mstop                              ...
            length(len) length(baseangle) length(tipangle)         ...
			length(wid) length(page) mcrossdir length(ends) length(shorten)];
args=['length(ObjectHandle)  '; ...
      '#rows(Start)          '; ...
      '#rows(Stop)           '; ...
      'length(Length)        '; ...
      'length(BaseAngle)     '; ...
      'length(TipAngle)      '; ...
      'length(Width)         '; ...
      'length(Page)          '; ...
      '#rows(CrossDir)       '; ...
      '#rows(Ends)           '; ...
      'length(ShortenLength) '];
if (any(imag(crossdir(:))~=0)),
	args(9,:) = '#rows(NormalDir)      ';
end;
if isempty(oldh),
	narrows = max(argsizes);
else,
	narrows = length(oldh);
end;
if (narrows<=0), narrows=1; end;

% Check size of arguments
ii = find((argsizes~=0)&(argsizes~=1)&(argsizes~=narrows));
if ~isempty(ii),
	s = args(ii',:);
	while ((size(s,2)>1)&((abs(s(:,size(s,2)))==0)|(abs(s(:,size(s,2)))==abs(' ')))),
		s = s(:,1:size(s,2)-1);
	end;
	s = [ones(length(ii),1)*[upper(mfilename) ' requires that  '] s ...
	     ones(length(ii),1)*['  equal the # of arrows (' num2str(narrows) ').' c]];
	s = s';
	s = s(:)';
	s = s(1:length(s)-1);
	error(setstr(s));
end;

% check element length in Start, Stop, and CrossDir
if ~isempty(start),
	[m,n] = size(start);
	if (n==2),
		start = [start NaN*ones(m,1)];
	elseif (n~=3),
		error([upper(mfilename) ' requires 2- or 3-element Start points.']);
	end;
end;
if ~isempty(stop),
	[m,n] = size(stop);
	if (n==2),
		stop = [stop NaN*ones(m,1)];
	elseif (n~=3),
		error([upper(mfilename) ' requires 2- or 3-element Stop points.']);
	end;
end;
if ~isempty(crossdir),
	[m,n] = size(crossdir);
	if (n<3),
		crossdir = [crossdir NaN*ones(m,3-n)];
	elseif (n~=3),
		if (all(imag(crossdir(:))==0)),
			error([upper(mfilename) ' requires 2- or 3-element CrossDir vectors.']);
		else,
			error([upper(mfilename) ' requires 2- or 3-element NormalDir vectors.']);
		end;
	end;
end;

% fill empty arguments
if isempty(start     ),   start      = [Inf Inf Inf];      end;
if isempty(stop      ),   stop       = [Inf Inf Inf];      end;
if isempty(len       ),   len        = Inf;                end;
if isempty(baseangle ),   baseangle  = Inf;                end;
if isempty(tipangle  ),   tipangle   = Inf;                end;
if isempty(wid       ),   wid        = Inf;                end;
if isempty(page      ),   page       = Inf;                end;
if isempty(crossdir  ),   crossdir   = [Inf Inf Inf];      end;
if isempty(ends      ),   ends       = Inf;                end;
if isempty(shorten   ),   shorten    = Inf;                end;
if isempty(ispatch   ),   ispatch    = Inf;                end;

% expand single-column arguments
o = ones(narrows,1);
if (size(start     ,1)==1),   start      = o * start     ;   end;
if (size(stop      ,1)==1),   stop       = o * stop      ;   end;
if (length(len       )==1),   len        = o * len       ;   end;
if (length(baseangle )==1),   baseangle  = o * baseangle ;   end;
if (length(tipangle  )==1),   tipangle   = o * tipangle  ;   end;
if (length(wid       )==1),   wid        = o * wid       ;   end;
if (length(page      )==1),   page       = o * page      ;   end;
if (size(crossdir  ,1)==1),   crossdir   = o * crossdir  ;   end;
if (length(ends      )==1),   ends       = o * ends      ;   end;
if (length(shorten   )==1),   shorten    = o * shorten   ;   end;
if (length(ispatch   )==1),   ispatch    = o * ispatch   ;   end;
ax = repmat(gca,narrows,1);   %eaj 7/16/14  ax=gca; if ~isnumeric(ax), ax=double(ax); end; ax=o*ax;

% if we've got handles, get the defaults from the handles
if ~isempty(oldh),
	for k=1:narrows,
		oh = oldh(k);
		ud = get(oh,'UserData');
		ax(k) = get(oh,'Parent');   %eaj 7/16/14  get(oh,'Parent'); if ~isnumeric(ans), double(ans); end; ax(k)=ans;
		ohtype = get(oh,'Type');
		if strcmp(get(oh,'Tag'),ArrowTag), % if it's an arrow already
			if isinf(ispatch(k)), ispatch(k)=strcmp(ohtype,'patch'); end;
			% arrow UserData format: [start' stop' len base tip wid page crossdir' ends shorten]
			start0 = ud(1:3);
			stop0  = ud(4:6);
			if (isinf(len(k))),           len(k)        = ud( 7);   end;
			if (isinf(baseangle(k))),     baseangle(k)  = ud( 8);   end;
			if (isinf(tipangle(k))),      tipangle(k)   = ud( 9);   end;
			if (isinf(wid(k))),           wid(k)        = ud(10);   end;
			if (isinf(page(k))),          page(k)       = ud(11);   end;
			if (isinf(crossdir(k,1))),    crossdir(k,1) = ud(12);   end;
			if (isinf(crossdir(k,2))),    crossdir(k,2) = ud(13);   end;
			if (isinf(crossdir(k,3))),    crossdir(k,3) = ud(14);   end;
			if (isinf(ends(k))),          ends(k)       = ud(15);   end;
			if (isinf(shorten(k))),       shorten(k)    = ud(16);   end;
		elseif strcmp(ohtype,'line')|strcmp(ohtype,'patch'), % it's a non-arrow line or patch
			convLineToPatch = 1; %set to make arrow patches when converting from lines.
			if isinf(ispatch(k)), ispatch(k)=convLineToPatch|strcmp(ohtype,'patch'); end;
			x=get(oh,'XData');  x=x(~isnan(x(:)));  if isempty(x), x=NaN; end;
			y=get(oh,'YData');  y=y(~isnan(y(:)));  if isempty(y), y=NaN; end;
			z=get(oh,'ZData');  z=z(~isnan(z(:)));  if isempty(z), z=NaN; end;
			start0 = [x(1)   y(1)   z(1)  ];
			stop0  = [x(end) y(end) z(end)];
		else,
			error([upper(mfilename) ' cannot convert ' ohtype ' objects.']);
		end;
		ii=find(isinf(start(k,:)));  if ~isempty(ii),  start(k,ii)=start0(ii);  end;
		ii=find(isinf(stop( k,:)));  if ~isempty(ii),  stop( k,ii)=stop0( ii);  end;
	end;
end;

% convert Inf's to NaN's
start(     isinf(start    )) = NaN;
stop(      isinf(stop     )) = NaN;
len(       isinf(len      )) = NaN;
baseangle( isinf(baseangle)) = NaN;
tipangle(  isinf(tipangle )) = NaN;
wid(       isinf(wid      )) = NaN;
page(      isinf(page     )) = NaN;
crossdir(  isinf(crossdir )) = NaN;
ends(      isinf(ends     )) = NaN;
shorten(   isinf(shorten  )) = NaN;
ispatch(   isinf(ispatch  )) = NaN;

% set up the UserData data (here so not corrupted by log10's and such)
ud = [start stop len baseangle tipangle wid page crossdir ends shorten];

% Set Page defaults
page = ~isnan(page) & trueornan(page);

% Get axes limits, range, min; correct for aspect ratio and log scale
axm       = zeros(3,narrows);
axr       = zeros(3,narrows);
axrev     = zeros(3,narrows);
ap        = zeros(2,narrows);
xyzlog    = zeros(3,narrows);
limmin    = zeros(2,narrows);
limrange  = zeros(2,narrows);
oldaxlims = zeros(6,narrows);
oneax = all(ax==ax(1));
if (oneax),
	T    = zeros(4,4);
	invT = zeros(4,4);
else,
	T    = zeros(16,narrows);
	invT = zeros(16,narrows);
end;
axnotdone = true(size(ax));
while (any(axnotdone)),
	ii = find(axnotdone,1);
	curax = ax(ii);
	curpage = page(ii);
	% get axes limits and aspect ratio
	axl = [get(curax,'XLim'); get(curax,'YLim'); get(curax,'ZLim')];
	ax==curax; oldaxlims(:,ans)=repmat(reshape(axl',[],1),1,sum(ans));
	% get axes size in pixels (points)
	u = get(curax,'Units');
	axposoldunits = get(curax,'Position');
	really_curpage = curpage & strcmp(u,'normalized');
	if (really_curpage),
		curfig = get(curax,'Parent');
		pu = get(curfig,'PaperUnits');
		set(curfig,'PaperUnits','points');
		pp = get(curfig,'PaperPosition');
		set(curfig,'PaperUnits',pu);
		set(curax,'Units','pixels');
		curapscreen = get(curax,'Position');
		set(curax,'Units','normalized');
		curap = pp.*get(curax,'Position');
	else,
		set(curax,'Units','pixels');
		curapscreen = get(curax,'Position');
		curap = curapscreen;
	end;
	set(curax,'Units',u);
	set(curax,'Position',axposoldunits);
	% handle non-stretched axes position
	str_stretch = { 'DataAspectRatioMode'    ; ...
	                'PlotBoxAspectRatioMode' ; ...
	                'CameraViewAngleMode'      };
	str_camera  = { 'CameraPositionMode'  ; ...
	                'CameraTargetMode'    ; ...
	                'CameraViewAngleMode' ; ...
	                'CameraUpVectorMode'    };
	notstretched = strcmp(get(curax,str_stretch),'manual');
	manualcamera = strcmp(get(curax,str_camera),'manual');
	if ~arrow_WarpToFill(notstretched,manualcamera,curax),
		% give a warning that this has not been thoroughly tested
		if 0 & ARROW_STRETCH_WARN,
			ARROW_STRETCH_WARN = 0;
			strs = {str_stretch{1:2},str_camera{:}};
			strs = [char(ones(length(strs),1)*sprintf('\n    ')) char(strs)]';
			warning([upper(mfilename) ' may not yet work quite right ' ...
			         'if any of the following are ''manual'':' strs(:).']);
		end;
		% find the true pixel size of the actual axes
		texttmp = text(axl(1,[1 2 2 1 1 2 2 1]), ...
		               axl(2,[1 1 2 2 1 1 2 2]), ...
		               axl(3,[1 1 1 1 2 2 2 2]),'');
		set(texttmp,'Units','points');
		textpos = get(texttmp,'Position');
		delete(texttmp);
		textpos = cat(1,textpos{:});
		textpos = max(textpos(:,1:2)) - min(textpos(:,1:2));
		% adjust the axes position
		if (really_curpage),
			% adjust to printed size
			textpos = textpos * min(curap(3:4)./textpos);
			curap = [curap(1:2)+(curap(3:4)-textpos)/2 textpos];
		else,
			% adjust for pixel roundoff
			textpos = textpos * min(curapscreen(3:4)./textpos);
			curap = [curap(1:2)+(curap(3:4)-textpos)/2 textpos];
		end;
	end;
	if ARROW_PERSP_WARN & ~strcmp(get(curax,'Projection'),'orthographic'),
		ARROW_PERSP_WARN = 0;
		warning([upper(mfilename) ' does not yet work right for 3-D perspective projection.']);
	end;
	% adjust limits for log scale on axes
	curxyzlog = strcmp(get(curax,{'XScale' 'YScale' 'ZScale'})','log');
	if (any(curxyzlog)),
		ii = find([curxyzlog;curxyzlog]);
		if (any(axl(ii)<=0)),
			error([upper(mfilename) ' does not support non-positive limits on log-scaled axes.']);
		else,
			axl(ii) = log10(axl(ii));
		end;
	end;
	% correct for 'reverse' direction on axes;
	curreverse = strcmp(get(curax,{'XDir' 'YDir' 'ZDir'})','reverse');
	ii = find(curreverse);
	if ~isempty(ii),
		axl(ii,[1 2])=-axl(ii,[2 1]);
	end;
	% compute the range of 2-D values
	try, curT=get(curax,'Xform'); catch, num2cell(get(curax,'View')); curT=viewmtx(ans{:}); end;
	lim = curT*[0 1 0 1 0 1 0 1;0 0 1 1 0 0 1 1;0 0 0 0 1 1 1 1;1 1 1 1 1 1 1 1];
	lim = lim(1:2,:)./([1;1]*lim(4,:));
	curlimmin = min(lim')';
	curlimrange = max(lim')' - curlimmin;
	curinvT = inv(curT);
	if (~oneax),
		curT = curT.';
		curinvT = curinvT.';
		curT = curT(:);
		curinvT = curinvT(:);
	end;
	% check which arrows to which cur corresponds
	ii = find((ax==curax)&(page==curpage));
	oo = ones(1,length(ii));
	axr(:,ii)      = diff(axl')' * oo;
	axm(:,ii)      = axl(:,1)    * oo;
	axrev(:,ii)    = curreverse  * oo;
	ap(:,ii)       = curap(3:4)' * oo;
	xyzlog(:,ii)   = curxyzlog   * oo;
	limmin(:,ii)   = curlimmin   * oo;
	limrange(:,ii) = curlimrange * oo;
	if (oneax),
		T    = curT;
		invT = curinvT;
	else,
		T(:,ii)    = curT    * oo;
		invT(:,ii) = curinvT * oo;
	end;
	axnotdone(ii) = zeros(1,length(ii));
end;

% correct for log scales
curxyzlog = xyzlog.';
ii = find(curxyzlog(:));
if ~isempty(ii),
	start(   ii) = real(log10(start(   ii)));
	stop(    ii) = real(log10(stop(    ii)));
	if (all(imag(crossdir)==0)), % pulled (ii) subscript on crossdir, 12/5/96 eaj
		crossdir(ii) = real(log10(crossdir(ii)));
	end;
end;

% correct for reverse directions
ii = find(axrev.');
if ~isempty(ii),
	start(   ii) = -start(   ii);
	stop(    ii) = -stop(    ii);
	crossdir(ii) = -crossdir(ii);
end;

% transpose start/stop values
start     = start.';
stop      = stop.';

% take care of defaults, page was done above
ii=find(isnan(start(:)       ));  if ~isempty(ii),  start(ii)       = axm(ii)+axr(ii)/2;                end;
ii=find(isnan(stop(:)        ));  if ~isempty(ii),  stop(ii)        = axm(ii)+axr(ii)/2;                end;
ii=find(isnan(crossdir(:)    ));  if ~isempty(ii),  crossdir(ii)    = zeros(length(ii),1);              end;
ii=find(isnan(len            ));  if ~isempty(ii),  len(ii)         = ones(length(ii),1)*deflen;        end;
ii=find(isnan(baseangle      ));  if ~isempty(ii),  baseangle(ii)   = ones(length(ii),1)*defbaseangle;  end;
ii=find(isnan(tipangle       ));  if ~isempty(ii),  tipangle(ii)    = ones(length(ii),1)*deftipangle;   end;
ii=find(isnan(wid            ));  if ~isempty(ii),  wid(ii)         = ones(length(ii),1)*defwid;        end;
ii=find(isnan(ends           ));  if ~isempty(ii),  ends(ii)        = ones(length(ii),1)*defends;       end;
ii=find(isnan(shorten        ));  if ~isempty(ii),  shorten(ii)     = ones(length(ii),1)*defshorten;    end;

% transpose rest of values
len       = len.';
baseangle = baseangle.';
tipangle  = tipangle.';
wid       = wid.';
page      = page.';
crossdir  = crossdir.';
ends      = ends.';
shorten   = shorten.';
ax        = ax.';

% given x, a 3xN matrix of points in 3-space;
% want to convert to X, the corresponding 4xN 2-space matrix
%
%   tmp1=[(x-axm)./axr; ones(1,size(x,1))];
%   if (oneax), X=T*tmp1;
%   else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=T.*tmp1;
%         tmp2=zeros(4,4*N); tmp2(:)=tmp1(:);
%         X=zeros(4,N); X(:)=sum(tmp2)'; end;
%   X = X ./ (ones(4,1)*X(4,:));

% for all points with start==stop, start=stop-(verysmallvalue)*(up-direction);
ii = find(all(start==stop));
if ~isempty(ii),
	% find an arrowdir vertical on screen and perpendicular to viewer
	%	transform to 2-D
		tmp1 = [(stop(:,ii)-axm(:,ii))./axr(:,ii);ones(1,length(ii))];
		if (oneax), twoD=T*tmp1;
		else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=T(:,ii).*tmp1;
		      tmp2=zeros(4,4*length(ii)); tmp2(:)=tmp1(:);
		      twoD=zeros(4,length(ii)); twoD(:)=sum(tmp2)'; end;
		twoD=twoD./(ones(4,1)*twoD(4,:));
	%	move the start point down just slightly
		tmp1 = twoD + [0;-1/1000;0;0]*(limrange(2,ii)./ap(2,ii));
	%	transform back to 3-D
		if (oneax), threeD=invT*tmp1;
		else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=invT(:,ii).*tmp1;
		      tmp2=zeros(4,4*length(ii)); tmp2(:)=tmp1(:);
		      threeD=zeros(4,length(ii)); threeD(:)=sum(tmp2)'; end;
		start(:,ii) = (threeD(1:3,:)./(ones(3,1)*threeD(4,:))).*axr(:,ii)+axm(:,ii);
end;

% compute along-arrow points
%	transform Start points
	tmp1=[(start-axm)./axr;ones(1,narrows)];
	if (oneax), X0=T*tmp1;
	else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=T.*tmp1;
	      tmp2=zeros(4,4*narrows); tmp2(:)=tmp1(:);
	      X0=zeros(4,narrows); X0(:)=sum(tmp2)'; end;
	X0=X0./(ones(4,1)*X0(4,:));
%	transform Stop points
	tmp1=[(stop-axm)./axr;ones(1,narrows)];
	if (oneax), Xf=T*tmp1;
	else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=T.*tmp1;
	      tmp2=zeros(4,4*narrows); tmp2(:)=tmp1(:);
	      Xf=zeros(4,narrows); Xf(:)=sum(tmp2)'; end;
	Xf=Xf./(ones(4,1)*Xf(4,:));
%	compute pixel distance between points
	D = sqrt(sum(((Xf(1:2,:)-X0(1:2,:)).*(ap./limrange)).^2));
	D = D + (D==0);  %eaj new 2/24/98
%       shorten the length if requested % added 2/6/2013
	numends = (ends==1) + (ends==2) + 2*(ends==3);
	mask = shorten & D%	compute and modify along-arrow distances
	len1 = len;
	len2 = len - (len.*tan(tipangle/180*pi)-wid/2).*tan((90-baseangle)/180*pi);
	slen0 = zeros(1,narrows);
	slen1 = len1 .* ((ends==2)|(ends==3));
	slen2 = len2 .* ((ends==2)|(ends==3));
	len0 = zeros(1,narrows);
	len1  = len1 .* ((ends==1)|(ends==3));
	len2  = len2 .* ((ends==1)|(ends==3));
	%	for no start arrowhead
		ii=find((ends==1)&(Dif ~isempty(ii),
			slen0(ii) = D(ii)-len2(ii);
		end;
	%	for no end arrowhead
		ii=find((ends==2)&(Dif ~isempty(ii),
			len0(ii) = D(ii)-slen2(ii);
		end;
	len1  = len1  + len0;
	len2  = len2  + len0;
	slen1 = slen1 + slen0;
	slen2 = slen2 + slen0;
 	% note:  the division by D below will probably not be accurate if both
 	%        of the following are true:
 	%           1. the ratio of the line length to the arrowhead
 	%              length is large
 	%           2. the view is highly perspective.
%	compute stoppoints
	tmp1=X0.*(ones(4,1)*(len0./D))+Xf.*(ones(4,1)*(1-len0./D));
	if (oneax), tmp3=invT*tmp1;
	else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=invT.*tmp1;
	      tmp2=zeros(4,4*narrows); tmp2(:)=tmp1(:);
	      tmp3=zeros(4,narrows); tmp3(:)=sum(tmp2)'; end;
	stoppoint = tmp3(1:3,:)./(ones(3,1)*tmp3(4,:)).*axr+axm;
%	compute tippoints
	tmp1=X0.*(ones(4,1)*(len1./D))+Xf.*(ones(4,1)*(1-len1./D));
	if (oneax), tmp3=invT*tmp1;
	else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=invT.*tmp1;
	      tmp2=zeros(4,4*narrows); tmp2(:)=tmp1(:);
	      tmp3=zeros(4,narrows); tmp3(:)=sum(tmp2)'; end;
	tippoint = tmp3(1:3,:)./(ones(3,1)*tmp3(4,:)).*axr+axm;
%	compute basepoints
	tmp1=X0.*(ones(4,1)*(len2./D))+Xf.*(ones(4,1)*(1-len2./D));
	if (oneax), tmp3=invT*tmp1;
	else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=invT.*tmp1;
	      tmp2=zeros(4,4*narrows); tmp2(:)=tmp1(:);
	      tmp3=zeros(4,narrows); tmp3(:)=sum(tmp2)'; end;
	basepoint = tmp3(1:3,:)./(ones(3,1)*tmp3(4,:)).*axr+axm;
%	compute startpoints
	tmp1=X0.*(ones(4,1)*(1-slen0./D))+Xf.*(ones(4,1)*(slen0./D));
	if (oneax), tmp3=invT*tmp1;
	else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=invT.*tmp1;
	      tmp2=zeros(4,4*narrows); tmp2(:)=tmp1(:);
	      tmp3=zeros(4,narrows); tmp3(:)=sum(tmp2)'; end;
	startpoint = tmp3(1:3,:)./(ones(3,1)*tmp3(4,:)).*axr+axm;
%	compute stippoints
	tmp1=X0.*(ones(4,1)*(1-slen1./D))+Xf.*(ones(4,1)*(slen1./D));
	if (oneax), tmp3=invT*tmp1;
	else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=invT.*tmp1;
	      tmp2=zeros(4,4*narrows); tmp2(:)=tmp1(:);
	      tmp3=zeros(4,narrows); tmp3(:)=sum(tmp2)'; end;
	stippoint = tmp3(1:3,:)./(ones(3,1)*tmp3(4,:)).*axr+axm;
%	compute sbasepoints
	tmp1=X0.*(ones(4,1)*(1-slen2./D))+Xf.*(ones(4,1)*(slen2./D));
	if (oneax), tmp3=invT*tmp1;
	else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=invT.*tmp1;
	      tmp2=zeros(4,4*narrows); tmp2(:)=tmp1(:);
	      tmp3=zeros(4,narrows); tmp3(:)=sum(tmp2)'; end;
	sbasepoint = tmp3(1:3,:)./(ones(3,1)*tmp3(4,:)).*axr+axm;

% compute cross-arrow directions for arrows with NormalDir specified
if (any(imag(crossdir(:))~=0)),
	ii = find(any(imag(crossdir)~=0));
	crossdir(:,ii) = cross((stop(:,ii)-start(:,ii))./axr(:,ii), ...
	                       imag(crossdir(:,ii))).*axr(:,ii);
end;

% compute cross-arrow directions
basecross  = crossdir + basepoint;
tipcross   = crossdir + tippoint;
sbasecross = crossdir + sbasepoint;
stipcross  = crossdir + stippoint;
ii = find(all(crossdir==0)|any(isnan(crossdir)));
if ~isempty(ii),
	numii = length(ii);
	%	transform start points
		tmp1 = [basepoint(:,ii) tippoint(:,ii) sbasepoint(:,ii) stippoint(:,ii)];
		tmp1 = (tmp1-axm(:,[ii ii ii ii])) ./ axr(:,[ii ii ii ii]);
		tmp1 = [tmp1; ones(1,4*numii)];
		if (oneax), X0=T*tmp1;
		else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=T(:,[ii ii ii ii]).*tmp1;
		      tmp2=zeros(4,16*numii); tmp2(:)=tmp1(:);
		      X0=zeros(4,4*numii); X0(:)=sum(tmp2)'; end;
		X0=X0./(ones(4,1)*X0(4,:));
	%	transform stop points
		tmp1 = [(2*stop(:,ii)-start(:,ii)-axm(:,ii))./axr(:,ii);ones(1,numii)];
		tmp1 = [tmp1 tmp1 tmp1 tmp1];
		if (oneax), Xf=T*tmp1;
		else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=T(:,[ii ii ii ii]).*tmp1;
		      tmp2=zeros(4,16*numii); tmp2(:)=tmp1(:);
		      Xf=zeros(4,4*numii); Xf(:)=sum(tmp2)'; end;
		Xf=Xf./(ones(4,1)*Xf(4,:));
	%	compute perpendicular directions
		pixfact = ((limrange(1,ii)./limrange(2,ii)).*(ap(2,ii)./ap(1,ii))).^2;
		pixfact = [pixfact pixfact pixfact pixfact];
		pixfact = [pixfact;1./pixfact];
		[dummyval,jj] = max(abs(Xf(1:2,:)-X0(1:2,:)));
		jj1 = ((1:4)'*ones(1,length(jj))==ones(4,1)*jj);
		jj2 = ((1:4)'*ones(1,length(jj))==ones(4,1)*(3-jj));
		jj3 = jj1(1:2,:);
		Xf(jj1)=Xf(jj1)+(Xf(jj1)-X0(jj1)==0); %eaj new 2/24/98
		Xp = X0;
		Xp(jj2) = X0(jj2) + ones(sum(jj2(:)),1);
		Xp(jj1) = X0(jj1) - (Xf(jj2)-X0(jj2))./(Xf(jj1)-X0(jj1)) .* pixfact(jj3);
	%	inverse transform the cross points
		if (oneax), Xp=invT*Xp;
		else, tmp1=[Xp;Xp;Xp;Xp]; tmp1=invT(:,[ii ii ii ii]).*tmp1;
		      tmp2=zeros(4,16*numii); tmp2(:)=tmp1(:);
		      Xp=zeros(4,4*numii); Xp(:)=sum(tmp2)'; end;
		Xp=(Xp(1:3,:)./(ones(3,1)*Xp(4,:))).*axr(:,[ii ii ii ii])+axm(:,[ii ii ii ii]);
		basecross(:,ii)  = Xp(:,0*numii+(1:numii));
		tipcross(:,ii)   = Xp(:,1*numii+(1:numii));
		sbasecross(:,ii) = Xp(:,2*numii+(1:numii));
		stipcross(:,ii)  = Xp(:,3*numii+(1:numii));
end;

% compute all points
%	compute start points
	axm11 = [axm axm axm axm axm axm axm axm axm axm axm];
	axr11 = [axr axr axr axr axr axr axr axr axr axr axr];
	st = [stoppoint tippoint basepoint sbasepoint stippoint startpoint stippoint sbasepoint basepoint tippoint stoppoint];
	tmp1 = (st - axm11) ./ axr11;
	tmp1 = [tmp1; ones(1,size(tmp1,2))];
	if (oneax), X0=T*tmp1;
	else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=[T T T T T T T T T T T].*tmp1;
	      tmp2=zeros(4,44*narrows); tmp2(:)=tmp1(:);
	      X0=zeros(4,11*narrows); X0(:)=sum(tmp2)'; end;
	X0=X0./(ones(4,1)*X0(4,:));
%	compute stop points
	tmp1 = ([start tipcross basecross sbasecross stipcross stop stipcross sbasecross basecross tipcross start] ...
	     - axm11) ./ axr11;
	tmp1 = [tmp1; ones(1,size(tmp1,2))];
	if (oneax), Xf=T*tmp1;
	else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=[T T T T T T T T T T T].*tmp1;
	      tmp2=zeros(4,44*narrows); tmp2(:)=tmp1(:);
	      Xf=zeros(4,11*narrows); Xf(:)=sum(tmp2)'; end;
	Xf=Xf./(ones(4,1)*Xf(4,:));
%	compute lengths
	len0  = len.*((ends==1)|(ends==3)).*tan(tipangle/180*pi);
	slen0 = len.*((ends==2)|(ends==3)).*tan(tipangle/180*pi);
	le = [zeros(1,narrows) len0 wid/2 wid/2 slen0 zeros(1,narrows) -slen0 -wid/2 -wid/2 -len0 zeros(1,narrows)];
	aprange = ap./limrange;
	aprange = [aprange aprange aprange aprange aprange aprange aprange aprange aprange aprange aprange];
	D = sqrt(sum(((Xf(1:2,:)-X0(1:2,:)).*aprange).^2));
	Dii=find(D==0); if ~isempty(Dii), D=D+(D==0); le(Dii)=zeros(1,length(Dii)); end; %should fix DivideByZero warnings
	tmp1 = X0.*(ones(4,1)*(1-le./D)) + Xf.*(ones(4,1)*(le./D));
%	inverse transform
	if (oneax), tmp3=invT*tmp1;
	else, tmp1=[tmp1;tmp1;tmp1;tmp1]; tmp1=[invT invT invT invT invT invT invT invT invT invT invT].*tmp1;
	      tmp2=zeros(4,44*narrows); tmp2(:)=tmp1(:);
	      tmp3=zeros(4,11*narrows); tmp3(:)=sum(tmp2)'; end;
	pts = tmp3(1:3,:)./(ones(3,1)*tmp3(4,:)) .* axr11 + axm11;

% correct for ones where the crossdir was specified
ii = find(~(all(crossdir==0)|any(isnan(crossdir))));
if ~isempty(ii),
	D1 = [pts(:,1*narrows+ii)-pts(:,9*narrows+ii) ...
	      pts(:,2*narrows+ii)-pts(:,8*narrows+ii) ...
	      pts(:,3*narrows+ii)-pts(:,7*narrows+ii) ...
	      pts(:,4*narrows+ii)-pts(:,6*narrows+ii) ...
	      pts(:,6*narrows+ii)-pts(:,4*narrows+ii) ...
	      pts(:,7*narrows+ii)-pts(:,3*narrows+ii) ...
	      pts(:,8*narrows+ii)-pts(:,2*narrows+ii) ...
	      pts(:,9*narrows+ii)-pts(:,1*narrows+ii)]/2;
	ii = ii'*ones(1,8) + ones(length(ii),1)*[1:4 6:9]*narrows;
	ii = ii(:)';
	pts(:,ii) = st(:,ii) + D1;
end;


% readjust for reverse directions
iicols=(1:narrows)'; iicols=iicols(:,ones(1,11)); iicols=iicols(:).';
tmp1=axrev(:,iicols);
ii = find(tmp1(:)); if ~isempty(ii), pts(ii)=-pts(ii); end;

% change from starting/ending at the stop point to doing it at the midpoint %eaj 7/14/2014
(pts(:,2*narrows+1:3*narrows)+pts(:,3*narrows+1:4*narrows))/2;              %eaj 7/14/2014
pts = [ans pts(:,[3*narrows+1:end narrows+1:3*narrows]) ans];               %eaj 7/14/2014

% readjust for log scale on axes
tmp1=xyzlog(:,iicols);
ii = find(tmp1(:)); if ~isempty(ii), pts(ii)=10.^pts(ii); end;

% compute the x,y,z coordinates of the patches;
ii = narrows*(0:size(pts,2)/narrows-1)'*ones(1,narrows) + ones(size(pts,2)/narrows,1)*(1:narrows);
ii = ii(:)';
x = zeros(size(pts,2)/narrows,narrows);
y = zeros(size(pts,2)/narrows,narrows);
z = zeros(size(pts,2)/narrows,narrows);
x(:) = pts(1,ii)';
y(:) = pts(2,ii)';
z(:) = pts(3,ii)';

% do the output
if (nargout<=1),
%	% create or modify the patches
	newpatch = trueornan(ispatch) & (isempty(oldh)|~strcmp(get(oldh,'Type'),'patch'));
	newline = ~trueornan(ispatch) & (isempty(oldh)|~strcmp(get(oldh,'Type'),'line'));
	if isempty(oldh), H=zeros(narrows,1); else, H=oldh; end;
%	% make or modify the arrows
	for k=1:narrows,
		if all(isnan(ud(k,[3 6])))&arrow_is2DXY(ax(k)), zz=[]; else, zz=z(:,k); end;
		xx=x(:,k); yy=y(:,k);
		if (0), % this fix didn't work, so let's not use it -- 8/26/03
			% try to work around a MATLAB 6.x OpenGL bug -- 7/28/02
			  mask=any([ones(1,2+size(zz,2));diff([xx yy zz],[],1)],2);
			  xx=xx(mask); yy=yy(mask); if ~isempty(zz), zz=zz(mask); end;
		end;
		% plot the patch or line
		if newpatch(k) || trueornan(ispatch(k)) %eaj 7/14/2014, 5/25/2016
			% patch is closed so don't need endpoints %eaj 7/14/2014
			if ~isempty(xx), xx(end)=[]; end; %eaj 7/14/2014
			if ~isempty(yy), yy(end)=[]; end; %eaj 7/14/2014
			if ~isempty(zz), zz(end)=[]; end; %eaj 7/14/2014
		end %eaj 7/14/2014
		xyz = {'XData',xx,'YData',yy,'ZData',zz,'Tag',ArrowTag};
		if newpatch(k)|newline(k),
			if newpatch(k),
				H(k) = patch(xyz{:});
			else,
				H(k) = line(xyz{:});
			end;
			if ~isempty(oldh), arrow_copyprops(oldh(k),H(k)); end;
		else,
			if strcmp(get(H(k),'Type'),'patch') %eaj 5/25/16  if ispatch(k)
				xyz = {xyz{:},'CData',[]};
			end;
			set(H(k),xyz{:});
		end;
	end;
	if ~isempty(oldh), delete(oldh(oldh~=H)); end;
%	% additional properties
	set(H,'Clipping','off');
	set(H,{'UserData'},num2cell(ud,2));
	if length(extraprops)>0
		ii = find(strcmpi(extraprops(1:2:end),'color')); %eaj 5/25/16
		ispatch = strcmp(get(H,'Type'),'patch');
		%eaj start 5/25/16
			while ~isempty(ii) && any(ispatch)
				if ii>1, set(H,extraprops{1:2*ii-2}); end;
				c = extraprops{2*ii};
				extraprops(1:2*ii) = [];
				ii(1) = [];
				if all(ispatch) || ischar(c)&&size(c,1)==1 || isnumeric(c)&&isequal(size(c),[1 3])
					set(H,'EdgeColor',c,'FaceColor',c)
				elseif iscell(c) && numel(c)~=numel(H)
					set(H(ispatch),'EdgeColor',c(ispatch),'FaceColor',c(ispatch));
					set(H(~ispatch),'Color',c(~ispatch));
				elseif isnumeric(c) && isequal(size(c),[numel(H) 3])
					set(H(ispatch),'EdgeColor',num2cell(c(ispatch,:),2),'FaceColor',num2cell(c(ispatch,:),2));
					set(H(~ispatch),'Color',num2cell(c(~ispatch,:),2));
				else
					warning('ignoring unknown or invalid ''Color'' specification');
				end
			end
		if ~isempty(extraprops)
		%eaj end   5/25/16
			set(H,extraprops{:});
		end %eaj   5/25/16
	end
	% handle choosing arrow Start and/or Stop locations if unspecified
	[H,oldaxlims,errstr] = arrow_clicks(H,ud,x,y,z,ax,oldaxlims);
	if ~isempty(errstr), error([upper(mfilename) ' got ' errstr]); end;
	% set the output
	if (nargout>0), h=H; end;
	% make sure the axis limits did not change
	if isempty(oldaxlims),
		ARROW_AXLIMITS = [];
		ARROW_AX = [];
	else,
		lims = get(ax(:),{'XLim','YLim','ZLim'})';
		lims = reshape(cat(2,lims{:}),6,size(lims,2));
		mask = arrow_is2DXY(ax(:));
		oldaxlims(5:6,mask) = lims(5:6,mask);
		% store them for possible restoring
		mask = any(oldaxlims~=lims,1); ARROW_AX=ax(mask); ARROW_AXLIMITS=oldaxlims(:,mask);
		if any(mask),
			warning(arrow_warnlimits(ARROW_AX,narrows));
		end;
	end;
else,
	% don't create the patch, just return the data
	h=x;
	yy=y;
	zz=z;
end;



function out = arrow_defcheck(in,def,prop)
% check if we got 'default' values
	out = in;
	if ~isstr(in), return; end;
	if size(in,1)==1 & strncmp(lower(in),'def',3),
		out = def;
	elseif ~isempty(prop),
		error([upper(mfilename) ' does not recognize ''' in(:)' ''' as a valid ''' prop ''' string.']);
	end;



function [H,oldaxlims,errstr] = arrow_clicks(H,ud,x,y,z,ax,oldaxlims)
% handle choosing arrow Start and/or Stop locations if necessary
	errstr = '';
	if isempty(H)|isempty(ud)|isempty(x), return; end;
	% determine which (if any) need Start and/or Stop
	needStart = all(isnan(ud(:,1:3)'))';
	needStop  = all(isnan(ud(:,4:6)'))';
	mask = any(needStart|needStop);
	if ~any(mask), return; end;
	ud(~mask,:)=[]; ax(:,~mask)=[];
	x(:,~mask)=[]; y(:,~mask)=[]; z(:,~mask)=[];
	% make them invisible for the time being
	set(H,'Visible','off');
	% save the current axes and limits modes; set to manual for the time being
	oldAx  = gca;
	limModes=get(ax(:),{'XLimMode','YLimMode','ZLimMode'});
	set(ax(:),{'XLimMode','YLimMode','ZLimMode'},{'manual','manual','manual'});
	% loop over each arrow that requires attention
	jj = find(mask);
	for ii=1:length(jj),
		h = H(jj(ii));
		axes(ax(ii));
		% figure out correct call
		if needStart(ii), prop='Start'; else, prop='Stop'; end;
		[wasInterrupted,errstr] = arrow_click(needStart(ii)&needStop(ii),h,prop,ax(ii));
		% handle errors and control-C
		if wasInterrupted,
			delete(H(jj(ii:end)));
			H(jj(ii:end))=[];
			oldaxlims(jj(ii:end),:)=[];
			break;
		end;
	end;
	% restore the axes and limit modes
	axes(oldAx);
	set(ax(:),{'XLimMode','YLimMode','ZLimMode'},limModes);

function [wasInterrupted,errstr] = arrow_click(lockStart,H,prop,ax)
% handle the clicks for one arrow
	fig = get(ax,'Parent');
	% save some things
	oldFigProps = {'Pointer','WindowButtonMotionFcn','WindowButtonUpFcn'};
	oldFigValue = get(fig,oldFigProps);
	oldArrowProps = {'EraseMode'};
	if ~isnumeric(fig), oldArrowProps={}; end %eaj 5/24/16 % only use in HG2
	oldArrowValue = get(H,oldArrowProps);
	if isnumeric(fig), %eaj 5/24/16
		set(H,'EraseMode','background'); %because 'xor' makes shaft invisible unless Width>1 -- only use in HG2
	end %eaj 5/24/16
	global ARROW_CLICK_H ARROW_CLICK_PROP ARROW_CLICK_AX ARROW_CLICK_USE_Z
	ARROW_CLICK_H=H; ARROW_CLICK_PROP=prop; ARROW_CLICK_AX=ax;
	ARROW_CLICK_USE_Z=~arrow_is2DXY(ax)|~arrow_planarkids(ax);
	set(fig,'Pointer','crosshair');
	% set up the WindowButtonMotion so we can see the arrow while moving around
	set(fig,'WindowButtonUpFcn','set(gcf,''WindowButtonUpFcn'','''')', ...
	        'WindowButtonMotionFcn','');
	if ~lockStart,
		set(H,'Visible','on');
		set(fig,'WindowButtonMotionFcn',[mfilename '(''callback'',''motion'');']);
	end;
	% wait for the button to be pressed
	[wasKeyPress,wasInterrupted,errstr] = arrow_wfbdown(fig);
	% if we wanted to click-drag, set the Start point
	if lockStart & ~wasInterrupted,
		pt = arrow_point(ARROW_CLICK_AX,ARROW_CLICK_USE_Z);
		feval(mfilename,H,'Start',pt,'Stop',pt);
		set(H,'Visible','on');
		ARROW_CLICK_PROP='Stop';
		set(fig,'WindowButtonMotionFcn',[mfilename '(''callback'',''motion'');']);
		% wait for the mouse button to be released
		try
			waitfor(fig,'WindowButtonUpFcn','');
		catch
			errstr = lasterr;
			wasInterrupted = 1;
		end;
	end;
	if ~wasInterrupted, feval(mfilename,'callback','motion'); end;
	% restore some things
	set(gcf,oldFigProps,oldFigValue);
	set(H,oldArrowProps,oldArrowValue);

function arrow_callback(varargin)
% handle redrawing callbacks
	if nargin==0, return; end;
	str = varargin{1};
	if ~isstr(str), error([upper(mfilename) ' got an invalid Callback command.']); end;
	s = lower(str);
	if strcmp(s,'motion'),
		% motion callback
		global ARROW_CLICK_H ARROW_CLICK_PROP ARROW_CLICK_AX ARROW_CLICK_USE_Z
		feval(mfilename,ARROW_CLICK_H,ARROW_CLICK_PROP,arrow_point(ARROW_CLICK_AX,ARROW_CLICK_USE_Z));
		drawnow;
	else,
		error([upper(mfilename) ' does not recognize ''' str(:).' ''' as a valid Callback option.']);
	end;

function out = arrow_point(ax,use_z)
% return the point on the given axes
	if nargin==0, ax=gca; end;
	if nargin<2, use_z=~arrow_is2DXY(ax)|~arrow_planarkids(ax); end;
	out = get(ax,'CurrentPoint');
	out = out(1,:);
	if ~use_z, out=out(1:2); end;

function [wasKeyPress,wasInterrupted,errstr] = arrow_wfbdown(fig)
% wait for button down ignoring object ButtonDownFcn's
	if nargin==0, fig=gcf; end;
	errstr = '';
	% save ButtonDownFcn values
	objs = findobj(fig);
	buttonDownFcns = get(objs,'ButtonDownFcn');
	mask=~strcmp(buttonDownFcns,''); objs=objs(mask); buttonDownFcns=buttonDownFcns(mask);
	set(objs,'ButtonDownFcn','');
	% save other figure values
	figProps = {'KeyPressFcn','WindowButtonDownFcn'};
	figValue = get(fig,figProps);
	% do the real work
	set(fig,'KeyPressFcn','set(gcf,''KeyPressFcn'','''',''WindowButtonDownFcn'','''');', ...
	        'WindowButtonDownFcn','set(gcf,''WindowButtonDownFcn'','''')');
	lasterr('');
	try
		waitfor(fig,'WindowButtonDownFcn','');
		wasInterrupted = 0;
	catch
		wasInterrupted = 1;
	end
	wasKeyPress = ~wasInterrupted & strcmp(get(fig,'KeyPressFcn'),'');
	if wasInterrupted, errstr=lasterr; end;
	% restore ButtonDownFcn and other figure values
	set(objs,'ButtonDownFcn',buttonDownFcns);
	set(fig,figProps,figValue);



function [out,is2D] = arrow_is2DXY(ax)
% check if axes are 2-D X-Y plots
	% may not work for modified camera angles, etc.
	out = false(size(ax)); % 2-D X-Y plots
	is2D = out;                     % any 2-D plots
	views = get(ax(:),{'View'});
	views = cat(1,views{:});
	out(:) = abs(views(:,2))==90;
	is2D(:) = out(:) | all(rem(views',90)==0)';

function out = arrow_planarkids(ax)
% check if axes descendents all have empty ZData (lines,patches,surfaces)
	out = true(size(ax));
	allkids = get(ax(:),{'Children'});
	for k=1:length(allkids),
		kids = get([findobj(allkids{k},'flat','Type','line')
		            findobj(allkids{k},'flat','Type','patch')
		            findobj(allkids{k},'flat','Type','surface')],{'ZData'});
		for j=1:length(kids),
			if ~isempty(kids{j}), out(k)=logical(0); break; end;
		end;
	end;



function arrow_fixlimits(ax,lims)
% reset the axis limits as necessary
	if isempty(ax) || isempty(lims), disp([upper(mfilename) ' does not remember any axis limits to reset.']); end;
	for k=1:numel(ax),
		if any(get(ax(k),'XLim')~=lims(1:2,k)'), set(ax(k),'XLim',lims(1:2,k)'); end;
		if any(get(ax(k),'YLim')~=lims(3:4,k)'), set(ax(k),'YLim',lims(3:4,k)'); end;
		if any(get(ax(k),'ZLim')~=lims(5:6,k)'), set(ax(k),'ZLim',lims(5:6,k)'); end;
	end;



function out = arrow_WarpToFill(notstretched,manualcamera,curax)
% check if we are in "WarpToFill" mode.
	out = strcmp(get(curax,'WarpToFill'),'on');
	% 'WarpToFill' is undocumented, so may need to replace this by
	% out = ~( any(notstretched) & any(manualcamera) );



function out = arrow_warnlimits(ax,narrows)
% create a warning message if we've changed the axis limits
	msg = '';
	switch (numel(ax))
		case 1, msg='';
		case 2, msg='on two axes ';
		otherwise, msg='on several axes ';
	end;
	msg = [upper(mfilename) ' changed the axis limits ' msg ...
	       'when adding the arrow'];
	if (narrows>1), msg=[msg 's']; end;
	out = [msg '.' sprintf('\n') '         Call ' upper(mfilename) ...
	       ' FIXLIMITS to reset them now.'];



function arrow_copyprops(fm,to)
% copy line properties to patches
	props  = {'EraseMode','LineStyle','LineWidth','Marker','MarkerSize',...
	          'MarkerEdgeColor','MarkerFaceColor','ButtonDownFcn',      ...
	          'Clipping','DeleteFcn','BusyAction','HandleVisibility',   ...
	          'Selected','SelectionHighlight','Visible'};
	if ~isnumeric(findobj('Type','root')), props(strcmp(props,'EraseMode'))=[]; end; %eaj 5/24/16
	lineprops  = {'Color',    props{:}};
	patchprops = {'EdgeColor',props{:}};
	patch2props = {'FaceColor',patchprops{:}};
	fmpatch = strcmp(get(fm,'Type'),'patch');
	topatch = strcmp(get(to,'Type'),'patch');
	set(to( fmpatch& topatch),patch2props,get(fm( fmpatch& topatch),patch2props)); %p->p
	set(to(~fmpatch&~topatch),lineprops,  get(fm(~fmpatch&~topatch),lineprops  )); %l->l
	set(to( fmpatch&~topatch),lineprops,  get(fm( fmpatch&~topatch),patchprops )); %p->l
	set(to(~fmpatch& topatch),patchprops, get(fm(~fmpatch& topatch),lineprops)  ,'FaceColor','none'); %l->p



function arrow_props
% display further help info about ARROW properties
	c = sprintf('\n');
	disp([c ...
	'ARROW Properties:  Default values are given in [square brackets], and other' c ...
	'                   acceptable equivalent property names are in (parenthesis).' c c ...
	'  Start           The starting points. For N arrows,            B' c ...
	'                  this should be a Nx2 or Nx3 matrix.          /|\           ^' c ...
	'  Stop            The end points. For N arrows, this          /|||\          |' c ...
	'                  should be a Nx2 or Nx3 matrix.             //|||\\        L|' c ...
	'  Length          Length of the arrowhead (in pixels on     ///|||\\\       e|' c ...
	'                  screen, points on a page). [16] (Len)    ////|||\\\\      n|' c ...
	'  BaseAngle       Angle (degrees) of the base angle       /////|D|\\\\\     g|' c ...
	'                  ADE.  For a simple stick arrow, use    ////  |||  \\\\    t|' c ...
	'                  BaseAngle=TipAngle. [90] (Base)       ///    |||    \\\   h|' c ...
	'  TipAngle        Angle (degrees) of tip angle ABC.    //<----->||      \\   |' c ...
	'                  [16] (Tip)                          /   base |||        \  V' c ...
	'  Width           Width of the base in pixels.  Not  E   angle ||<-------->C' c ...
	'                  the ''LineWidth'' prop. [0] (Wid)            |||tipangle' c ...
	'  Page            If provided, non-empty, and not NaN,         |||' c ...
	'                  this causes ARROW to use hardcopy            |||' c ...
	'                  rather than onscreen proportions.             A' c ...
	'                  This is important if screen aspect        -->   <-- width' c ...
	'                  ratio and hardcopy aspect ratio are    ----CrossDir---->' c ...
	'                  vastly different. []' c...
	'  CrossDir        A vector giving the direction towards which the fletches' c ...
	'                  on the arrow should go.  [computed such that it is perpen-' c ...
	'                  dicular to both the arrow direction and the view direction' c ...
	'                  (i.e., as if it was pasted on a normal 2-D graph)]  (Note' c ...
	'                  that CrossDir is a vector.  Also note that if an axis is' c ...
	'                  plotted on a log scale, then the corresponding component' c ...
	'                  of CrossDir must also be set appropriately, i.e., to 1 for' c ...
	'                  no change in that direction, >1 for a positive change, >0' c ...
	'                  and <1 for negative change.)' c ...
	'  NormalDir       A vector normal to the fletch direction (CrossDir is then' c ...
	'                  computed by the vector cross product [Line]x[NormalDir]). []' c ...
	'                  (Note that NormalDir is a vector.  Unlike CrossDir,' c ...
	'                  NormalDir is used as is regardless of log-scaled axes.)' c ...
	'  Ends            Set which end has an arrowhead.  Valid values are ''none'',' c ...
	'                  ''stop'', ''start'', and ''both''. [''stop''] (End)' c...
	'  ShortenLength   Shorten length of arrowhead(s) if line is too short' c ...
	'  ObjectHandles   Vector of handles to previously-created arrows to be' c ...
	'                  updated or line objects to be converted to arrows.' c ...
	'                  [] (Object,Handle)' c ...
	'  Type            ''patch'' creates the arrow with a PATCH object (the default)' c ...
	'                  and ''line'' creates it with a LINE object [''patch''].' c ...
	'  Color           For patch arrows (the default), set both ''FaceColor'' and' c ...
	'                  ''EdgeColor'' to the given value.  For line arrows, set' c ...
	'                  the ''Color'' property to the given value.' c ...
	]);



function out = arrow_demo
 	% demo
	% create the data
	[x,y,z] = peaks;
	[ddd,out.iii]=max(z(:));
	out.axlim = [min(x(:)) max(x(:)) min(y(:)) max(y(:)) min(z(:)) max(z(:))];
	
	% modify it by inserting some NaN's
	[m,n] = size(z);
	m = floor(m/2);
	n = floor(n/2);
	z(1:m,1:n) = NaN*ones(m,n);
	
	% graph it
	clf('reset');
	out.hs=surf(x,y,z);
	out.x=x; out.y=y; out.z=z;
	xlabel('x'); ylabel('y');
			
function h = arrow_demo3(in)
	% set the view
	axlim = in.axlim;
	axis(axlim);
	zlabel('z');
	%set(in.hs,'FaceColor','interp');
	view(3); % view(viewmtx(-37.5,30,20));
	title(['Demo of the capabilities of the ARROW function in 3-D']);
	
	% Normal blue arrow
	h1 = feval(mfilename,[axlim(1) axlim(4) 4],[-.8 1.2 4], ...
	           'EdgeColor','b','FaceColor','b');
	
	% Normal white arrow, clipped by the surface
	h2 = feval(mfilename,axlim([1 4 6]),[0 2 4]);
	t=text(-2.4,2.7,7.7,'arrow clipped by surf');
	
	% Baseangle<90
	h3 = feval(mfilename,[3 .125 3.5],[1.375 0.125 3.5],30,50);
	t2=text(3.1,.125,3.5,'local maximum');
	
	% Baseangle<90, fill and edge colors different
	h4 = feval(mfilename,axlim(1:2:5)*.5,[0 0 0],36,60,25, ...
	           'EdgeColor','b','FaceColor','c');
	t3=text(axlim(1)*.5,axlim(3)*.5,axlim(5)*.5-.75,'origin');
	set(t3,'HorizontalAlignment','center');
	
	% Baseangle>90, black fill
	h5 = feval(mfilename,[-2.9 2.9 3],[-1.3 .4 3.2],30,120,[],6, ...
	           'EdgeColor','r','FaceColor','k','LineWidth',2);
	
	% Baseangle>90, no fill
	h6 = feval(mfilename,[-2.9 2.9 1.3],[-1.3 .4 1.5],30,120,[],6, ...
	           'EdgeColor','r','FaceColor','none','LineWidth',2);
	
	% Stick arrow
	h7 = feval(mfilename,[-1.6 -1.65 -6.5],[0 -1.65 -6.5],[],16,16);
	t4=text(-1.5,-1.65,-7.25,'global mininum');
	set(t4,'HorizontalAlignment','center');
	
	% Normal, black fill
	h8 = feval(mfilename,[-1.4 0 -7.2],[-1.4 0 -3],'FaceColor','k');
	t5=text(-1.5,0,-7.75,'local minimum');
	set(t5,'HorizontalAlignment','center');
	
	% Gray fill, crossdir specified, 'LineStyle' --
	h9 = feval(mfilename,[-3 2.2 -6],[-3 2.2 -.05],36,[],27,6,[],[0 -1 0], ...
	           'EdgeColor','k','FaceColor',.75*[1 1 1],'LineStyle','--');
	
	% a series of normal arrows, linearly spaced, crossdir specified
	h10y=(0:4)'/3;
	h10 = feval(mfilename,[-3*ones(size(h10y)) h10y -6.5*ones(size(h10y))], ...
	            [-3*ones(size(h10y)) h10y -.05*ones(size(h10y))], ...
	            12,[],[],[],[],[0 -1 0]);
	
	% a series of normal arrows, linearly spaced
	h11x=(1:.33:2.8)';
	h11 = feval(mfilename,[h11x -3*ones(size(h11x)) 6.5*ones(size(h11x))], ...
	            [h11x -3*ones(size(h11x)) -.05*ones(size(h11x))]);
	
	% series of magenta arrows, radially oriented, crossdir specified
	h12x=2; h12y=-3; h12z=axlim(5)/2; h12xr=1; h12zr=h12z; ir=.15;or=.81;
	h12t=(0:11)'/6*pi;
	h12 = feval(mfilename,                                           ...
	            [h12x+h12xr*cos(h12t)*ir h12y*ones(size(h12t))       ...
	             h12z+h12zr*sin(h12t)*ir],[h12x+h12xr*cos(h12t)*or   ...
	             h12y*ones(size(h12t)) h12z+h12zr*sin(h12t)*or],     ...
	            10,[],[],[],[],                                      ...
	            [-h12xr*sin(h12t) zeros(size(h12t)) h12zr*cos(h12t)],...
	            'FaceColor','none','EdgeColor','m');
	
	% series of normal arrows, tangentially oriented, crossdir specified
	or13=.91; h13t=(0:.5:12)'/6*pi;
	locs = [h12x+h12xr*cos(h13t)*or13 h12y*ones(size(h13t)) h12z+h12zr*sin(h13t)*or13];
	h13 = feval(mfilename,locs(1:end-1,:),locs(2:end,:),6);
	
	% arrow with no line ==> oriented downwards
	h14 = feval(mfilename,[3 3 .100001],[3 3 .1],30);
	t6=text(3,3,3.6,'no line'); set(t6,'HorizontalAlignment','center');
	
	% arrow with arrowheads at both ends
	h15 = feval(mfilename,[-.5 -3 -3],[1 -3 -3],'Ends','both','FaceColor','g', ...
	            'Length',20,'Width',3,'CrossDir',[0 0 1],'TipAngle',25);
	
	h=[h1;h2;h3;h4;h5;h6;h7;h8;h9;h10;h11;h12;h13;h14;h15];

function h = arrow_demo2(in)
	axlim = in.axlim;
	dolog = 1;
	if (dolog), set(in.hs,'YData',10.^get(in.hs,'YData')); end;
	shading('interp');
	view(2);
	title(['Demo of the capabilities of the ARROW function in 2-D']);
	hold on; [C,H]=contour(in.x,in.y,in.z,20,'-'); hold off;
	for k=H',
		set(k,'ZData',(axlim(6)+1)*ones(size(get(k,'XData'))),'Color','k');
		if (dolog), set(k,'YData',10.^get(k,'YData')); end;
	end;
	if (dolog), axis([axlim(1:2) 10.^axlim(3:4)]); set(gca,'YScale','log');
	else,       axis(axlim(1:4)); end;
	
	% Normal blue arrow
	start = [axlim(1) axlim(4) axlim(6)+2];
	stop  = [in.x(in.iii) in.y(in.iii) axlim(6)+2];
	if (dolog), start(:,2)=10.^start(:,2); stop(:,2)=10.^stop(:,2); end;
	h1 = feval(mfilename,start,stop,'EdgeColor','b','FaceColor','b');
	
	% three arrows with varying fill, width, and baseangle
	start = [-3   -3   10; -3   -1.5 10; -1.5 -3   10];
	stop  = [-.03 -.03 10; -.03 -1.5 10; -1.5 -.03 10];
	if (dolog), start(:,2)=10.^start(:,2); stop(:,2)=10.^stop(:,2); end;
	h2 = feval(mfilename,start,stop,24,[90;60;120],[],[0;0;4],'Ends',str2mat('both','stop','stop'));
	set(h2(2),'EdgeColor',[0 .35 0],'FaceColor',[0 .85 .85]);
	set(h2(3),'EdgeColor','r','FaceColor',[1 .5 1]);
	h=[h1;h2];

function out = trueornan(x)
if isempty(x),
	out=x;
else,
	out = isnan(x);
	out(~out) = x(~out);
end;