Exemple #1
0
void apply(const std::string& /*directory*/, std::vector<std::string>& files, bool /*reinit*/)
{


    sofa::simulation::Simulation* simulation = sofa::simulation::getSimulation();

    //Launch the comparison for each scenes
    for (unsigned int i = 0; i < files.size(); ++i)
    {

        const std::string& currentFile = files[i];
        GNode::SPtr groot = sofa::core::objectmodel::SPtr_dynamic_cast<GNode> (simulation->load(currentFile.c_str()));
        if (groot == NULL)
        {
            std::cerr << "CANNOT open " << currentFile << " !" << std::endl;
            continue;
        }
        std::cout << "sec. Loading " << currentFile << std::endl;

        //Save the initial time
        clock_t curtime = clock();
        simulation->init(groot.get());
        double t = static_cast<double>(clock() - curtime) / (float)CLOCKS_PER_SEC;
        std::cout << "Init time " << t << " sec." << std::endl;

        //Clear and prepare for next scene
        simulation->unload(groot);
        groot.reset();
    }
}
Exemple #2
0
/// Move a node from another node
void GNode::moveChild(BaseNode::SPtr node)
{
    GNode::SPtr gnode = sofa::core::objectmodel::SPtr_dynamic_cast<GNode>(node);
    if (!gnode) return;
    GNode* prev = gnode->parent();
    if (prev==NULL)
    {
        addChild(node);
    }
    else
    {
        notifyMoveChild(gnode,prev);
        prev->doRemoveChild(gnode);
        doAddChild(gnode);
    }
}
Exemple #3
0
// ---------------------------------------------------------------------
// ---
// ---------------------------------------------------------------------
int main(int argc, char** argv)
{

    glutInit(&argc,argv);
    sofa::helper::parse("This is a SOFA application.")
        (argc,argv);
    sofa::gui::GUIManager::Init(argv[0]);

    // The graph root node
    GNode::SPtr groot = sofa::core::objectmodel::New<GNode>();
    groot->setName( "root" );
    groot->setGravity( Coord3(0,-10,0) );
    
    // One solver for all the graph
    EulerSolver::SPtr solver = sofa::core::objectmodel::New<EulerSolver>();
    solver->setName("solver");
    solver->f_printLog.setValue(false);
    groot->addObject(solver);

    // One node to define the particle
    GNode::SPtr particule_node = sofa::core::objectmodel::New<GNode>("particle_node", groot.get());

    // The particule, i.e, its degrees of freedom : a point with a velocity
    MechanicalObject3::SPtr particle = sofa::core::objectmodel::New<MechanicalObject3>();
    particle->setName("particle");
    particule_node->addObject(particle);
    particle->resize(1);
    // get write access the particle positions vector
    WriteAccessor< Data<MechanicalObject3::VecCoord> > positions = *particle->write( VecId::position() );
    positions[0] = Coord3(0,0,0);
    // get write access the particle velocities vector
    WriteAccessor< Data<MechanicalObject3::VecDeriv> > velocities = *particle->write( VecId::velocity() );
    velocities[0] = Deriv3(0,0,0);
    
    // Its properties, i.e, a simple mass node
    UniformMass3::SPtr mass = sofa::core::objectmodel::New<UniformMass3>();
    mass->setName("mass");
    particule_node->addObject(mass);
    mass->setMass( 1 );

    // Display Flags
    sofa::component::visualmodel::VisualStyle::SPtr style = sofa::core::objectmodel::New<sofa::component::visualmodel::VisualStyle>();
    groot->addObject(style);
    sofa::core::visual::DisplayFlags& flags = *style->displayFlags.beginEdit();
    flags.setShowBehaviorModels(true);
    style->displayFlags.endEdit();

    sofa::simulation::tree::getSimulation()->init(groot.get());
    groot->setAnimate(false);

	//=======================================
	// Run the main loop
    sofa::gui::GUIManager::MainLoop(groot);

	return 0;
}
Exemple #4
0
// ---------------------------------------------------------------------
// ---
// ---------------------------------------------------------------------
int main(int argc, char** argv)
{
    glutInit(&argc,argv);
	sofa::helper::parse("This is a SOFA application.")
        (argc,argv);
    
    sofa::gui::GUIManager::Init(argv[0]);
    
    // The graph root node : gravity already exists in a GNode by default
    GNode::SPtr groot = sofa::core::objectmodel::New<GNode>();
    groot->setName( "root" );
    groot->setGravity( Coord3(0,-10,0) );

    // One solver for all the graph
    EulerSolver::SPtr solver = sofa::core::objectmodel::New<EulerSolver>();
    solver->setName("solver");
    solver->f_printLog.setValue(false);
    groot->addObject(solver);

    // Tetrahedron degrees of freedom
    MechanicalObject3::SPtr DOF = sofa::core::objectmodel::New<MechanicalObject3>();
    groot->addObject(DOF);
    DOF->resize(4);
    DOF->setName("DOF");
    //get write access to the position vector of mechanical object DOF 
    WriteAccessor<Data<VecCoord3> > x = *DOF->write(VecId::position());
    
    x[0] = Coord3(0,10,0);
    x[1] = Coord3(10,0,0);
    x[2] = Coord3(-10*0.5,0,10*0.866);
    x[3] = Coord3(-10*0.5,0,-10*0.866);

    // Tetrahedron uniform mass
    UniformMass3::SPtr mass = sofa::core::objectmodel::New<UniformMass3>();
    groot->addObject(mass);
    mass->setMass(2);
    mass->setName("mass");
  
    // Tetrahedron topology
    MeshTopology::SPtr topology = sofa::core::objectmodel::New<MeshTopology>();
    topology->setName("mesh topology");
    groot->addObject( topology );
    topology->addTetra(0,1,2,3);

    // Tetrahedron constraints
    FixedConstraint3::SPtr constraints = sofa::core::objectmodel::New<FixedConstraint3>();
    constraints->setName("constraints");
    groot->addObject(constraints);
    constraints->addConstraint(0);

    // Tetrahedron force field
    TetrahedronFEMForceField3::SPtr fem = sofa::core::objectmodel::New<TetrahedronFEMForceField3>();
    fem->setName("FEM");
    groot->addObject(fem);
    fem->setMethod("polar");
    fem->setUpdateStiffnessMatrix(true);
    fem->setYoungModulus(6);

    // Tetrahedron skin
    GNode::SPtr skin = sofa::core::objectmodel::New<GNode>("skin",groot.get());;

    // The visual model
    OglModel::SPtr visual = sofa::core::objectmodel::New<OglModel>();
    visual->setName( "visual" );
    visual->load(sofa::helper::system::DataRepository.getFile("mesh/liver-smooth.obj"), "", "");
    visual->setColor("red");
    visual->applyScale(0.7, 0.7, 0.7);
    visual->applyTranslation(1.2, 0.8, 0);
    skin->addObject(visual);
        
    // The mapping between the tetrahedron (DOF) and the liver (visual)
    BarycentricMapping3_to_Ext3::SPtr mapping = sofa::core::objectmodel::New<BarycentricMapping3_to_Ext3>();
    mapping->setModels(DOF.get(), visual.get());
    mapping->setName( "mapping" );
    skin->addObject(mapping);

    // Display Flags
    sofa::component::visualmodel::VisualStyle::SPtr style = sofa::core::objectmodel::New<sofa::component::visualmodel::VisualStyle>();
    groot->addObject(style);
    sofa::core::visual::DisplayFlags& flags = *style->displayFlags.beginEdit();
    flags.setShowNormals(false);
    flags.setShowInteractionForceFields(false);
    flags.setShowMechanicalMappings(false);
    flags.setShowCollisionModels(false);
    flags.setShowBoundingCollisionModels(false);	
    flags.setShowMappings(false);
    flags.setShowForceFields(true);
    flags.setShowWireFrame(true);
    flags.setShowVisualModels(true);
    flags.setShowBehaviorModels(true);
    style->displayFlags.endEdit();

    // Init the scene
    sofa::simulation::tree::getSimulation()->init(groot.get());
    groot->setAnimate(false);


	//=======================================
	// Run the main loop
	sofa::gui::GUIManager::MainLoop(groot);

	return 0;
}
Exemple #5
0
void apply(const std::string& directory, std::vector<std::string>& files,
        unsigned int iterations, bool reinit, bool useTopology)
{

    sofa::component::init(); // ensures all components are initialized, also introduce a dependency to all libraries, avoiding problems with -Wl,--as-needed flag

    sofa::simulation::Simulation* simulation = sofa::simulation::getSimulation();

    //Launch the comparison for each scenes
    for (unsigned int i = 0; i < files.size(); ++i)
    {

        const std::string& currentFile = files[i];
        GNode::SPtr groot = sofa::core::objectmodel::SPtr_dynamic_cast<GNode> (simulation->load(currentFile.c_str()));
        if (groot == NULL)
        {
            std::cerr << "CANNOT open " << currentFile << " !" << std::endl;
            continue;
        }

        simulation->init(groot.get());

        //Filename where the simulation of the current scene will be saved (in Sofa/applications/projects/sofaVerification/simulation/)
        std::string refFile;
        if(directory.empty())
        {
            refFile += SetDirectory::GetParentDir(DataRepository.getFirstPath().c_str());
            refFile += "/applications/projects/sofaVerification/simulation/";
            refFile += SetDirectory::GetFileName(currentFile.c_str());
        }
        else
        {
            refFile += directory;
            refFile += '/';
            refFile += SetDirectory::GetFileName(currentFile.c_str());
        }

        //If we initialize the system, we add only WriteState components, to store the reference states
        if (reinit)
        {
            if (useTopology)
            {
                sofa::component::misc::WriteTopologyCreator writeVisitor(sofa::core::ExecParams::defaultInstance());

                writeVisitor.setCreateInMapping(true);
                writeVisitor.setSceneName(refFile);
                writeVisitor.execute(groot.get());

                sofa::component::misc::WriteTopologyActivator v_write(sofa::core::ExecParams::defaultInstance() /* PARAMS FIRST */, true);
                v_write.execute(groot.get());
            }
            else
            {
                sofa::component::misc::WriteStateCreator writeVisitor(sofa::core::ExecParams::defaultInstance());

                writeVisitor.setCreateInMapping(true);
                writeVisitor.setSceneName(refFile);
                writeVisitor.execute(groot.get());

                sofa::component::misc::WriteStateActivator v_write(sofa::core::ExecParams::defaultInstance() /* PARAMS FIRST */, true);
                v_write.execute(groot.get());
            }

        }
        else
        {
            if (useTopology)
            {
                //We add CompareTopology components: as it derives from the ReadTopology, we use the ReadTopologyActivator to enable them.
                sofa::component::misc::CompareTopologyCreator compareVisitor(sofa::core::ExecParams::defaultInstance());
                compareVisitor.setCreateInMapping(true);
                compareVisitor.setSceneName(refFile);
                compareVisitor.execute(groot.get());

                sofa::component::misc::ReadTopologyActivator v_read(sofa::core::ExecParams::defaultInstance(),true);
                v_read.execute(groot.get());
            }
            else
            {
                //We add CompareState components: as it derives from the ReadState, we use the ReadStateActivator to enable them.
                sofa::component::misc::CompareStateCreator compareVisitor(sofa::core::ExecParams::defaultInstance());
                compareVisitor.setCreateInMapping(true);
                compareVisitor.setSceneName(refFile);
                compareVisitor.execute(groot.get());

                sofa::component::misc::ReadStateActivator v_read(sofa::core::ExecParams::defaultInstance() /* PARAMS FIRST */, true);
                v_read.execute(groot.get());
            }
        }

        //Do as many iterations as specified in entry of the program. At each step, the compare state will compare the computed states to the recorded states
        std::cout << "Computing " << iterations << " for " << currentFile << std::endl;

        //Save the initial time
        clock_t curtime = clock();
        for (unsigned int i = 0; i < iterations; i++)
        {
            simulation->animate(groot.get());
        }
        double t = static_cast<double>(clock() - curtime) / CLOCKS_PER_SEC;

        std::cout << "ITERATIONS " << iterations << " TIME " << t << " seconds ";

        //We read the final error: the summation of all the error made at each time step
        if (!reinit)
        {
            if (useTopology)
            {
                sofa::component::misc::CompareTopologyResult result(sofa::core::ExecParams::defaultInstance());
                result.execute(groot.get());
                std::cout << "ERROR " << result.getTotalError() << ' ';

                const std::vector<unsigned int>& listResult = result.getErrors();
                if (listResult.size() != 5)
                {
                    std::cerr
                            << "ERROR while reading detail of errors by topological element."
                                    << std::endl;
                    break;
                }

                std::cout
                        << "ERROR by element type "
                                << " EDGES "      << static_cast<double>(listResult[0])
                                / result.getNumCompareTopology()
                                << " TRIANGLES "  << static_cast<double>(listResult[1])
                                / result.getNumCompareTopology()
                                << " QUADS "      << static_cast<double>(listResult[2])
                                / result.getNumCompareTopology()
                                << " TETRAHEDRA " << static_cast<double>(listResult[3])
                                / result.getNumCompareTopology()
                                << " HEXAHEDRA "  << static_cast<double>(listResult[4])
                                / result.getNumCompareTopology();
            }
            else
            {
                sofa::component::misc::CompareStateResult result(sofa::core::ExecParams::defaultInstance());
                result.execute(groot.get());
                std::cout
                        << "ERROR " << result.getTotalError() << " ERRORBYDOF "
                                << static_cast<double>(result.getErrorByDof())
                                / result.getNumCompareState() << std::endl;
            }
        }
        std::cout << std::endl;

        //Clear and prepare for next scene
        simulation->unload(groot.get());
        groot.reset();
    }
}