Solid To Solid Collision #515

skydark88 · 2024-01-30T15:18:37Z

skydark88
Jan 30, 2024

Dear all,
I am tried to modified example Taylor bar to model column to column collision , i have deleted wall and add 1 column again and also modified in taylor_bar.cpp , for contact dynamic i have change to ContactDensitySummation --> for solid to solid contact
The code working without error but there is no contact between two of that column , please to help solved this problem.

The results

taylor_bar.cpp
/**

@file taylor_bar.cpp
@brief This is the case setup for plastic taylor bar.
@author Chi Zhang and Xiangyu Hu
@ref doi.org/10.1007/s40571-019-00277-6
*/
#include "sphinxsys.h"

#include "taylor_bar.h" /**< Case setup for this example. */

using namespace SPH;

int main(int ac, char* av[])
{
/** Setup the system. Please the make sure the global domain bounds are correctly defined. */
SPHSystem system(system_domain_bounds, particle_spacing_ref);
system.setRunParticleRelaxation(false);
system.setReloadParticles(true);
#ifdef BOOST_AVAILABLE
system.handleCommandlineOptions(ac, av);
#endif

IOEnvironment io_environment1(system);
IOEnvironment io_environment2(system);

/** create body 1. */
SolidBody column1(system, makeShared<Column1>("Column1"));
column1.defineAdaptationRatios(1.3, 1.0);
column1.defineBodyLevelSetShape()->writeLevelSet(io_environment1);
column1.defineParticlesAndMaterial<ElasticSolidParticles, HardeningPlasticSolid>(
	rho0_s, Youngs_modulus, poisson, yield_stress, hardening_modulus);
(!system.RunParticleRelaxation() && system.ReloadParticles())
	? column1.generateParticles<ParticleGeneratorReload>(io_environment1, column1.getName())
	: column1.generateParticles<ParticleGeneratorLattice>();
column1.addBodyStateForRecording<Vecd>("NormalDirection");

/** create body 2. */
SolidBody column2(system, makeShared<Column2>("Column2"));
column2.defineAdaptationRatios(1.3, 1.0);
column2.defineBodyLevelSetShape()->writeLevelSet(io_environment2);
column2.defineParticlesAndMaterial<ElasticSolidParticles, HardeningPlasticSolid>(
	rho0_s, Youngs_modulus, poisson, yield_stress, hardening_modulus);
(!system.RunParticleRelaxation() && system.ReloadParticles())
	? column2.generateParticles<ParticleGeneratorReload>(io_environment2, column2.getName())
	: column2.generateParticles<ParticleGeneratorLattice>();
column2.addBodyStateForRecording<Vecd>("NormalDirection");

/** Define Observer. */
ObserverBody my_observer(system, "MyObserver");
my_observer.generateParticles<ColumnObserverParticleGenerator>();


/**body relation topology */
InnerRelation column1_inner(column1);
InnerRelation column2_inner(column2);
ContactRelation my_observer_contact(my_observer, { &column1 });
SurfaceContactRelation column1_to_column2_contact(column1, { &column2 });


/**define simple data file input and outputs functions. */
BodyStatesRecordingToVtp write_states(io_environment1, system.real_bodies_);


if (system.RunParticleRelaxation())
{
	/**
	 * @brief 	Methods used for particle relaxation.
	 */
	
	 /** Random reset the insert body particle position. */
	SimpleDynamics<RandomizeParticlePosition> random_column1_particles(column1);
	SimpleDynamics<RandomizeParticlePosition> random_column2_particles(column2);

	/** Write the body state to Vtp file. */
	BodyStatesRecordingToVtp write_column1_to_vtp(io_environment1, column1);
	BodyStatesRecordingToVtp write_column2_to_vtp(io_environment2, column2);
	
	/** Write the particle reload files. */

	ReloadParticleIO write_particle_reload_files1(io_environment1, column1);
	ReloadParticleIO write_particle_reload_files2(io_environment2, column2);

	/** A  Physics relaxation step. */
	relax_dynamics::RelaxationStepInner relaxation_step_inner1(column1_inner);
	relax_dynamics::RelaxationStepInner relaxation_step_inner2(column2_inner);
	
	/**
	 * @brief 	Particle relaxation starts here.
	 */
	random_column1_particles.parallel_exec(0.25);
	random_column2_particles.parallel_exec(0.25);
	relaxation_step_inner1.SurfaceBounding().parallel_exec();
	relaxation_step_inner2.SurfaceBounding().parallel_exec();

	write_states.writeToFile(0.0);

	/** relax particles of the insert body. */
	int ite_p = 0;
	while (ite_p < 1000)
	{
		relaxation_step_inner1.parallel_exec();
		relaxation_step_inner2.parallel_exec();
		ite_p += 1;
		if (ite_p % 200 == 0)
		{
			std::cout << std::fixed << setprecision(9) << "Relaxation steps for the column body N = " << ite_p << "\n";
			write_column1_to_vtp.writeToFile(ite_p);
			write_column2_to_vtp.writeToFile(ite_p);
		}
	}
	std::cout << "The physics relaxation process of cylinder body finish !" << std::endl;

	/** Output results. */
	write_particle_reload_files1.writeToFile(0.0);
	write_particle_reload_files2.writeToFile(0.0);
	return 0;
}
//----------------------------------------------------------------------
//	All numerical methods will be used in this case.
//----------------------------------------------------------------------
Dynamics1Level<solid_dynamics::PlasticIntegration1stHalf> stress_relaxation_first_half_column1(column1_inner);
Dynamics1Level<solid_dynamics::PlasticIntegration1stHalf> stress_relaxation_first_half_column2(column2_inner);
Dynamics1Level<solid_dynamics::Integration2ndHalf> stress_relaxation_second_half_column1(column1_inner);
Dynamics1Level<solid_dynamics::Integration2ndHalf> stress_relaxation_second_half_column2(column2_inner);
InteractionDynamics<solid_dynamics::ContactDensitySummation, BodyPartByParticle> column1_to_column2_contact_force(column1_to_column2_contact);

SimpleDynamics<InitialCondition1> initial_condition1(column1);
SimpleDynamics<InitialCondition2> initial_condition2(column2);

InteractionDynamics<solid_dynamics::CorrectConfiguration> corrected_configuration1(column1_inner);
InteractionDynamics<solid_dynamics::CorrectConfiguration> corrected_configuration2(column1_inner);

ReduceDynamics<solid_dynamics::AcousticTimeStepSize> computing_time_step_size1(column1, 0.3);
ReduceDynamics<solid_dynamics::AcousticTimeStepSize> computing_time_step_size2(column2, 0.3);

//----------------------------------------------------------------------
//	Output
//----------------------------------------------------------------------
RegressionTestDynamicTimeWarping<ObservedQuantityRecording<Vecd>>
	write_velocity("Velocity", io_environment1, my_observer_contact);
	
RegressionTestDynamicTimeWarping<ObservedQuantityRecording<Vecd>>
	write_displacement("Position", io_environment1, my_observer_contact);
	
RegressionTestTimeAveraged<ObservedQuantityRecording<Real>>
	write_column_stress("VonMisesStress", io_environment1, my_observer_contact);
	
RegressionTestTimeAveraged<ObservedQuantityRecording<Real>>
	write_column_strain("VonMisesStrain", io_environment1, my_observer_contact);
	

//----------------------------------------------------------------------
// From here the time stepping begins.
//----------------------------------------------------------------------
GlobalStaticVariables::physical_time_ = 0.0;
system.initializeSystemCellLinkedLists();
system.initializeSystemConfigurations();

corrected_configuration1.parallel_exec();
corrected_configuration2.parallel_exec();
initial_condition1.parallel_exec();
initial_condition2.parallel_exec();

//----------------------------------------------------------------------
// Setup time-stepping related simulation parameters.
//----------------------------------------------------------------------
int ite = 0;
Real end_time = 1.0e-4;
int screen_output_interval = 100;
int observation_sample_interval = screen_output_interval * 2;
Real output_period = 1.0e-6; // anyway 50 write_states files in total
Real dt = 0.0;
/** Statistics for computing time. */
tick_count t1 = tick_count::now();
tick_count::interval_t interval;

//----------------------------------------------------------------------
//	First output before the main loop.
//----------------------------------------------------------------------
write_states.writeToFile();
write_displacement.writeToFile(0);
write_velocity.writeToFile(0);

write_column_stress.writeToFile(0);

write_column_strain.writeToFile(0);


//----------------------------------------------------------------------
// Main time-stepping loop.
//----------------------------------------------------------------------
while (GlobalStaticVariables::physical_time_ < end_time)
{
	Real integration_time = 0.0;
	while (integration_time < output_period)
	{
		if (ite % screen_output_interval == 0)
		{
			std::cout << "N=" << ite << " Time: "
				<< GlobalStaticVariables::physical_time_ << "	dt: "
				<< dt << "\n";

			if (ite != 0 && ite % observation_sample_interval == 0)
			{
				write_displacement.writeToFile(ite);
				
				write_velocity.writeToFile(ite);
				
				write_column_stress.writeToFile(ite);
				
				write_column_strain.writeToFile(ite);
				
			}
		}
		column1_to_column2_contact_force.parallel_exec(dt);
		stress_relaxation_first_half_column1.parallel_exec(dt);
		stress_relaxation_first_half_column2.parallel_exec(dt);
		stress_relaxation_second_half_column1.parallel_exec(dt);
		stress_relaxation_second_half_column2.parallel_exec(dt);

		column1.updateCellLinkedList();
		column2.updateCellLinkedList();
		column1_to_column2_contact.updateConfiguration();

		ite++;
		dt = computing_time_step_size1.parallel_exec();
		integration_time += dt;
		GlobalStaticVariables::physical_time_ += dt;
	}
	tick_count t2 = tick_count::now();
	write_states.writeToFile();
	tick_count t3 = tick_count::now();
	interval += t3 - t2;
}
tick_count t4 = tick_count::now();

tick_count::interval_t tt;
tt = t4 - t1 - interval;
std::cout << "Total wall time for computation: " << tt.seconds() << " seconds." << endl;

write_displacement.newResultTest();


write_velocity.newResultTest();


write_column_stress.newResultTest();

write_column_strain.newResultTest();

return 0;

}

taylor_bar.h
/**

@file taylor_bar.h
@brief This is the case setup for plastic taylor bar.
@author xiaojing tang Chi Zhang and Xiangyu Hu
*/
#pragma once

#include "sphinxsys.h"
using namespace SPH;

//----------------------------------------------------------------------
// Global geometry parameters.
//----------------------------------------------------------------------
Real PL = 0.00381; /< X-direction domain. */
Real PW = 0.02347; /< Z-direction domain. */
Real particle_spacing_ref = PL / 5.0; /**particle spacing/

/** YOU can try PW = 0.2 and particle_spacing_ref = PH / 10.0 to see an interesting test. */
Real SL = particle_spacing_ref * 4.0; /**< Length of the holder is one layer particle. */
Real inner_circle_radius = PL;

Vec3d domain_lower_bound(-4.0 * PL, -4.0 * PL, -2.0 * PW);
Vec3d domain_upper_bound(4.0 * PL, 4.0 * PL, 2.0 * PW);
BoundingBox system_domain_bounds(domain_lower_bound, domain_upper_bound);
int resolution(20);

//----------------------------------------------------------------------
// Material properties and global parameters (Cu OFE)
//----------------------------------------------------------------------
Real rho0_s = 8968.0; /< Reference density. */
Real poisson = 0.34; /< Poisson ratio. */
Real Youngs_modulus = 1.15e11;
Real yield_stress = 1.0e8;
Real hardening_modulus = 1.15e9;

/** Define the body. /
class Column1 : public ComplexShape
{
public:
explicit Column1(const std::string& shape_name) : ComplexShape(shape_name)
{
Vecd translation_column(0.0, 0.0, 0.6 PW);
add(SimTK::UnitVec3(0, 0, 1.0), inner_circle_radius,
0.5 * PW, resolution, translation_column);
}
};

/**

application dependent initial condition
*/

class InitialCondition1
: public solid_dynamics::ElasticDynamicsInitialCondition
{
public:
explicit InitialCondition1(SPHBody& sph_body)
: solid_dynamics::ElasticDynamicsInitialCondition(sph_body) {};

void update(size_t index_i, Real dt)
{
	vel_[index_i][2] = -160;
}

};

/** Define the body. */
class Column2 : public ComplexShape
{
public:
explicit Column2(const std::string& shape_name) : ComplexShape(shape_name)
{
Vecd translation_column(0.0, 0.0, -0.5 * PW);
add(SimTK::UnitVec3(0, 0, 1.0), inner_circle_radius,
0.5 * PW, resolution, translation_column);
}
};

/**

application dependent initial condition 2
*/

class InitialCondition2
: public solid_dynamics::ElasticDynamicsInitialCondition
{
public:
explicit InitialCondition2(SPHBody& sph_body)
: solid_dynamics::ElasticDynamicsInitialCondition(sph_body) {};

void update(size_t index_i, Real dt)
{
	vel_[index_i][2] = 160;
}

};

// define an observer body
class ColumnObserverParticleGenerator : public ObserverParticleGenerator
{
public:
explicit ColumnObserverParticleGenerator(SPHBody& sph_body) : ObserverParticleGenerator(sph_body)
{
positions_.push_back(Vecd(0.0, 0.0, PW));
positions_.push_back(Vecd(PL, 0.0, 0.0));
}
};

Regards

Xiangyu-Hu · 2024-02-09T13:20:17Z

Xiangyu-Hu
Feb 9, 2024
Maintainer

Dear all, I am tried to modified example Taylor bar to model column to column collision , i have deleted wall and add 1 column again and also modified in taylor_bar.cpp , for contact dynamic i have change to ContactDensitySummation --> for solid to solid contact The code working without error but there is no contact between two of that column , please to help solved this problem.

The results

taylor_bar.cpp /**

* @file taylor_bar.cpp

* @brief This is the case setup for plastic taylor bar.

* @author Chi Zhang  and Xiangyu Hu

* @ref 	doi.org/10.1007/s40571-019-00277-6
  */
  #include "sphinxsys.h"

#include "taylor_bar.h" /**< Case setup for this example. */

using namespace SPH;

int main(int ac, char* av[]) { /** Setup the system. Please the make sure the global domain bounds are correctly defined. */ SPHSystem system(system_domain_bounds, particle_spacing_ref); system.setRunParticleRelaxation(false); system.setReloadParticles(true); #ifdef BOOST_AVAILABLE system.handleCommandlineOptions(ac, av); #endif

IOEnvironment io_environment1(system);
IOEnvironment io_environment2(system);

/** create body 1. */
SolidBody column1(system, makeShared<Column1>("Column1"));
column1.defineAdaptationRatios(1.3, 1.0);
column1.defineBodyLevelSetShape()->writeLevelSet(io_environment1);
column1.defineParticlesAndMaterial<ElasticSolidParticles, HardeningPlasticSolid>(
	rho0_s, Youngs_modulus, poisson, yield_stress, hardening_modulus);
(!system.RunParticleRelaxation() && system.ReloadParticles())
	? column1.generateParticles<ParticleGeneratorReload>(io_environment1, column1.getName())
	: column1.generateParticles<ParticleGeneratorLattice>();
column1.addBodyStateForRecording<Vecd>("NormalDirection");

/** create body 2. */
SolidBody column2(system, makeShared<Column2>("Column2"));
column2.defineAdaptationRatios(1.3, 1.0);
column2.defineBodyLevelSetShape()->writeLevelSet(io_environment2);
column2.defineParticlesAndMaterial<ElasticSolidParticles, HardeningPlasticSolid>(
	rho0_s, Youngs_modulus, poisson, yield_stress, hardening_modulus);
(!system.RunParticleRelaxation() && system.ReloadParticles())
	? column2.generateParticles<ParticleGeneratorReload>(io_environment2, column2.getName())
	: column2.generateParticles<ParticleGeneratorLattice>();
column2.addBodyStateForRecording<Vecd>("NormalDirection");

/** Define Observer. */
ObserverBody my_observer(system, "MyObserver");
my_observer.generateParticles<ColumnObserverParticleGenerator>();


/**body relation topology */
InnerRelation column1_inner(column1);
InnerRelation column2_inner(column2);
ContactRelation my_observer_contact(my_observer, { &column1 });
SurfaceContactRelation column1_to_column2_contact(column1, { &column2 });


/**define simple data file input and outputs functions. */
BodyStatesRecordingToVtp write_states(io_environment1, system.real_bodies_);


if (system.RunParticleRelaxation())
{
	/**
	 * @brief 	Methods used for particle relaxation.
	 */
	
	 /** Random reset the insert body particle position. */
	SimpleDynamics<RandomizeParticlePosition> random_column1_particles(column1);
	SimpleDynamics<RandomizeParticlePosition> random_column2_particles(column2);

	/** Write the body state to Vtp file. */
	BodyStatesRecordingToVtp write_column1_to_vtp(io_environment1, column1);
	BodyStatesRecordingToVtp write_column2_to_vtp(io_environment2, column2);
	
	/** Write the particle reload files. */

	ReloadParticleIO write_particle_reload_files1(io_environment1, column1);
	ReloadParticleIO write_particle_reload_files2(io_environment2, column2);

	/** A  Physics relaxation step. */
	relax_dynamics::RelaxationStepInner relaxation_step_inner1(column1_inner);
	relax_dynamics::RelaxationStepInner relaxation_step_inner2(column2_inner);
	
	/**
	 * @brief 	Particle relaxation starts here.
	 */
	random_column1_particles.parallel_exec(0.25);
	random_column2_particles.parallel_exec(0.25);
	relaxation_step_inner1.SurfaceBounding().parallel_exec();
	relaxation_step_inner2.SurfaceBounding().parallel_exec();

	write_states.writeToFile(0.0);

	/** relax particles of the insert body. */
	int ite_p = 0;
	while (ite_p < 1000)
	{
		relaxation_step_inner1.parallel_exec();
		relaxation_step_inner2.parallel_exec();
		ite_p += 1;
		if (ite_p % 200 == 0)
		{
			std::cout << std::fixed << setprecision(9) << "Relaxation steps for the column body N = " << ite_p << "\n";
			write_column1_to_vtp.writeToFile(ite_p);
			write_column2_to_vtp.writeToFile(ite_p);
		}
	}
	std::cout << "The physics relaxation process of cylinder body finish !" << std::endl;

	/** Output results. */
	write_particle_reload_files1.writeToFile(0.0);
	write_particle_reload_files2.writeToFile(0.0);
	return 0;
}
//----------------------------------------------------------------------
//	All numerical methods will be used in this case.
//----------------------------------------------------------------------
Dynamics1Level<solid_dynamics::PlasticIntegration1stHalf> stress_relaxation_first_half_column1(column1_inner);
Dynamics1Level<solid_dynamics::PlasticIntegration1stHalf> stress_relaxation_first_half_column2(column2_inner);
Dynamics1Level<solid_dynamics::Integration2ndHalf> stress_relaxation_second_half_column1(column1_inner);
Dynamics1Level<solid_dynamics::Integration2ndHalf> stress_relaxation_second_half_column2(column2_inner);
InteractionDynamics<solid_dynamics::ContactDensitySummation, BodyPartByParticle> column1_to_column2_contact_force(column1_to_column2_contact);

SimpleDynamics<InitialCondition1> initial_condition1(column1);
SimpleDynamics<InitialCondition2> initial_condition2(column2);

InteractionDynamics<solid_dynamics::CorrectConfiguration> corrected_configuration1(column1_inner);
InteractionDynamics<solid_dynamics::CorrectConfiguration> corrected_configuration2(column1_inner);

ReduceDynamics<solid_dynamics::AcousticTimeStepSize> computing_time_step_size1(column1, 0.3);
ReduceDynamics<solid_dynamics::AcousticTimeStepSize> computing_time_step_size2(column2, 0.3);

//----------------------------------------------------------------------
//	Output
//----------------------------------------------------------------------
RegressionTestDynamicTimeWarping<ObservedQuantityRecording<Vecd>>
	write_velocity("Velocity", io_environment1, my_observer_contact);
	
RegressionTestDynamicTimeWarping<ObservedQuantityRecording<Vecd>>
	write_displacement("Position", io_environment1, my_observer_contact);
	
RegressionTestTimeAveraged<ObservedQuantityRecording<Real>>
	write_column_stress("VonMisesStress", io_environment1, my_observer_contact);
	
RegressionTestTimeAveraged<ObservedQuantityRecording<Real>>
	write_column_strain("VonMisesStrain", io_environment1, my_observer_contact);
	

//----------------------------------------------------------------------
// From here the time stepping begins.
//----------------------------------------------------------------------
GlobalStaticVariables::physical_time_ = 0.0;
system.initializeSystemCellLinkedLists();
system.initializeSystemConfigurations();

corrected_configuration1.parallel_exec();
corrected_configuration2.parallel_exec();
initial_condition1.parallel_exec();
initial_condition2.parallel_exec();

//----------------------------------------------------------------------
// Setup time-stepping related simulation parameters.
//----------------------------------------------------------------------
int ite = 0;
Real end_time = 1.0e-4;
int screen_output_interval = 100;
int observation_sample_interval = screen_output_interval * 2;
Real output_period = 1.0e-6; // anyway 50 write_states files in total
Real dt = 0.0;
/** Statistics for computing time. */
tick_count t1 = tick_count::now();
tick_count::interval_t interval;

//----------------------------------------------------------------------
//	First output before the main loop.
//----------------------------------------------------------------------
write_states.writeToFile();
write_displacement.writeToFile(0);
write_velocity.writeToFile(0);

write_column_stress.writeToFile(0);

write_column_strain.writeToFile(0);


//----------------------------------------------------------------------
// Main time-stepping loop.
//----------------------------------------------------------------------
while (GlobalStaticVariables::physical_time_ < end_time)
{
	Real integration_time = 0.0;
	while (integration_time < output_period)
	{
		if (ite % screen_output_interval == 0)
		{
			std::cout << "N=" << ite << " Time: "
				<< GlobalStaticVariables::physical_time_ << "	dt: "
				<< dt << "\n";

			if (ite != 0 && ite % observation_sample_interval == 0)
			{
				write_displacement.writeToFile(ite);
				
				write_velocity.writeToFile(ite);
				
				write_column_stress.writeToFile(ite);
				
				write_column_strain.writeToFile(ite);
				
			}
		}
		column1_to_column2_contact_force.parallel_exec(dt);
		stress_relaxation_first_half_column1.parallel_exec(dt);
		stress_relaxation_first_half_column2.parallel_exec(dt);
		stress_relaxation_second_half_column1.parallel_exec(dt);
		stress_relaxation_second_half_column2.parallel_exec(dt);

		column1.updateCellLinkedList();
		column2.updateCellLinkedList();
		column1_to_column2_contact.updateConfiguration();

		ite++;
		dt = computing_time_step_size1.parallel_exec();
		integration_time += dt;
		GlobalStaticVariables::physical_time_ += dt;
	}
	tick_count t2 = tick_count::now();
	write_states.writeToFile();
	tick_count t3 = tick_count::now();
	interval += t3 - t2;
}
tick_count t4 = tick_count::now();

tick_count::interval_t tt;
tt = t4 - t1 - interval;
std::cout << "Total wall time for computation: " << tt.seconds() << " seconds." << endl;

write_displacement.newResultTest();


write_velocity.newResultTest();


write_column_stress.newResultTest();

write_column_strain.newResultTest();

return 0;

}

taylor_bar.h /**

* @file 	taylor_bar.h

* @brief 	This is the case setup for plastic taylor bar.

* @author 	xiaojing tang Chi Zhang and Xiangyu Hu
  */
  #pragma once

#include "sphinxsys.h" using namespace SPH;

//---------------------------------------------------------------------- // Global geometry parameters. //---------------------------------------------------------------------- Real PL = 0.00381; /< X-direction domain. */ Real PW = 0.02347; /< Z-direction domain. */ Real particle_spacing_ref = PL / 5.0; /**particle spacing/

/** YOU can try PW = 0.2 and particle_spacing_ref = PH / 10.0 to see an interesting test. */ Real SL = particle_spacing_ref * 4.0; /**< Length of the holder is one layer particle. */ Real inner_circle_radius = PL;

Vec3d domain_lower_bound(-4.0 * PL, -4.0 * PL, -2.0 * PW); Vec3d domain_upper_bound(4.0 * PL, 4.0 * PL, 2.0 * PW); BoundingBox system_domain_bounds(domain_lower_bound, domain_upper_bound); int resolution(20);

//---------------------------------------------------------------------- // Material properties and global parameters (Cu OFE) //---------------------------------------------------------------------- Real rho0_s = 8968.0; /< Reference density. */ Real poisson = 0.34; /< Poisson ratio. */ Real Youngs_modulus = 1.15e11; Real yield_stress = 1.0e8; Real hardening_modulus = 1.15e9;

/** Define the body. / class Column1 : public ComplexShape { public: explicit Column1(const std::string& shape_name) : ComplexShape(shape_name) { Vecd translation_column(0.0, 0.0, 0.6 PW); add(SimTK::UnitVec3(0, 0, 1.0), inner_circle_radius, 0.5 * PW, resolution, translation_column); } };

/**

* application dependent initial condition
  */

class InitialCondition1 : public solid_dynamics::ElasticDynamicsInitialCondition { public: explicit InitialCondition1(SPHBody& sph_body) : solid_dynamics::ElasticDynamicsInitialCondition(sph_body) {};

void update(size_t index_i, Real dt)
{
	vel_[index_i][2] = -160;
}

};

/** Define the body. */ class Column2 : public ComplexShape { public: explicit Column2(const std::string& shape_name) : ComplexShape(shape_name) { Vecd translation_column(0.0, 0.0, -0.5 * PW); add(SimTK::UnitVec3(0, 0, 1.0), inner_circle_radius, 0.5 * PW, resolution, translation_column); } };

/**

* application dependent initial condition 2
  */

class InitialCondition2 : public solid_dynamics::ElasticDynamicsInitialCondition { public: explicit InitialCondition2(SPHBody& sph_body) : solid_dynamics::ElasticDynamicsInitialCondition(sph_body) {};

void update(size_t index_i, Real dt)
{
	vel_[index_i][2] = 160;
}

};

// define an observer body class ColumnObserverParticleGenerator : public ObserverParticleGenerator { public: explicit ColumnObserverParticleGenerator(SPHBody& sph_body) : ObserverParticleGenerator(sph_body) { positions_.push_back(Vecd(0.0, 0.0, PW)); positions_.push_back(Vecd(PL, 0.0, 0.0)); } };

Regards

Dear Skydark,

For soild-solid contact, we have an example: test_3d_self_contact
You can have check.

Best,
Xiangyu
.

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Solid To Solid Collision #515

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Replies: 1 comment

{{title}}

Select a reply

Solid To Solid Collision #515

skydark88 Jan 30, 2024

Replies: 1 comment

Xiangyu-Hu Feb 9, 2024 Maintainer

skydark88
Jan 30, 2024

Xiangyu-Hu
Feb 9, 2024
Maintainer