Author: chareyre
Date: 2008-11-17 16:48:37 +0100 (Mon, 17 Nov 2008)
New Revision: 1574
Added:
trunk/pkg/dem/Engine/StandAloneEngine/MicroMacroAnalyser.cpp
trunk/pkg/dem/Engine/StandAloneEngine/MicroMacroAnalyser.hpp
Modified:
trunk/extra/triangulation/TesselationWrapper.h
trunk/pkg/dem/Engine/DeusExMachina/TriaxialCompressionEngine.hpp
trunk/pkg/dem/Engine/DeusExMachina/TriaxialStateRecorder.cpp
trunk/pkg/dem/Engine/DeusExMachina/TriaxialStressController.hpp
trunk/pkg/dem/Engine/StandAloneEngine/VolumicContactLaw.hpp
Log:
- Few files missing in the previous commit.
- Add a new class for computing/recording micromechanical data based on
tesselation
Modified: trunk/extra/triangulation/TesselationWrapper.h
===================================================================
--- trunk/extra/triangulation/TesselationWrapper.h 2008-11-17 15:41:43 UTC
(rev 1573)
+++ trunk/extra/triangulation/TesselationWrapper.h 2008-11-17 15:48:37 UTC
(rev 1574)
@@ -25,7 +25,7 @@
class TesselationWrapper{
-private:
+public:
Tesselation* Tes;
double mean_radius;
@@ -40,11 +40,10 @@
///Insert a sphere
bool insert(double x, double y, double z, double rad, unsigned int id);
+ void checkMinMax(double x, double y, double z, double rad);//for
experimentation purpose
bool move (double x, double y, double z, double rad, unsigned int id);
void clear(void);
-
-
-
+ void clear2(void);
///Add axis aligned bounding planes (modelised as spheres with (almost)
infinite radius)
// void AddBoundingPlanes (void);
Modified: trunk/pkg/dem/Engine/DeusExMachina/TriaxialCompressionEngine.hpp
===================================================================
--- trunk/pkg/dem/Engine/DeusExMachina/TriaxialCompressionEngine.hpp
2008-11-17 15:41:43 UTC (rev 1573)
+++ trunk/pkg/dem/Engine/DeusExMachina/TriaxialCompressionEngine.hpp
2008-11-17 15:48:37 UTC (rev 1574)
@@ -88,17 +88,12 @@
Real& uniaxialEpsilonCurr;
//! Value of friction to use for the compression test
Real frictionAngleDegree;
- //! document TODO
- Real spheresVolume;
- //! Value of spheres volume
- Real boxVolume;
- //! Value of box volume
- Real calculatedPorosity;
- //! Value of porosity during the simulation
- Real translationSpeed;
+
//! Value of translation speed
- Real fixedPorosity;
+ Real translationSpeed;
//! Value of porosity chosen by the user
+ Real fixedPorosity;
+
//! Previous state (used to detect manual changes of the state
in .xml)
stateNum previousState;
@@ -135,6 +130,7 @@
protected :
virtual void postProcessAttributes(bool);
virtual void registerAttributes();
+
REGISTER_CLASS_NAME(TriaxialCompressionEngine);
REGISTER_BASE_CLASS_NAME(TriaxialStressController);
};
Modified: trunk/pkg/dem/Engine/DeusExMachina/TriaxialStateRecorder.cpp
===================================================================
--- trunk/pkg/dem/Engine/DeusExMachina/TriaxialStateRecorder.cpp
2008-11-17 15:41:43 UTC (rev 1573)
+++ trunk/pkg/dem/Engine/DeusExMachina/TriaxialStateRecorder.cpp
2008-11-17 15:48:37 UTC (rev 1574)
@@ -183,5 +183,127 @@
}
+/*
+TriaxialStressController::ComputeLoveStress ( MetaBody * ncb )
+{
+ shared_ptr<BodyContainer>& bodies = ncb->bodies;
+ Real f1_el_x=0, f1_el_y=0, f1_el_z=0, x1=0, y1=0, z1=0, x2=0, y2=0,
z2=0;
+
+ Real sig11_el=0, sig22_el=0, sig33_el=0, sig12_el=0, sig13_el=0,
+ sig23_el=0;
+ //, Vwater = 0,
+ Real kinematicE = 0;
+
+ InteractionContainer::iterator ii = ncb->transientInteractions->begin();
+ InteractionContainer::iterator iiEnd = ncb->transientInteractions->end();
+
+ Real j = 0;
+ Real FT[3][3] = {{0,0,0},{0,0,0},{0,0,0}};
+
+ for ( ; ii!=iiEnd ; ++ii )
+ {
+ if ( ( *ii )->isReal )
+ {
+ const shared_ptr<Interaction>& interaction = *ii;
+
+ unsigned int id1 = interaction -> getId1();
+ unsigned int id2 = interaction -> getId2();
+
+ SpheresContactGeometry* currentContactGeometry =
+ static_cast<SpheresContactGeometry*> (
interaction->interactionGeometry.
+ get() );
+
+ ElasticContactInteraction* currentContactPhysics =
+ static_cast<ElasticContactInteraction*>
+ ( interaction->interactionPhysics.get() );
+
+ Real fn = currentContactPhysics->normalForce.Length();
+
+ if ( fn!=0 )
+
+ //if (currentContactGeometry->penetrationDepth
>= 0)
+
+ {
+ j=j+1;
+
+ Vector3r fel =
+ currentContactPhysics->normalForce +
currentContactPhysics->shearForce;
+
+ f1_el_x=fel[0];
+ f1_el_y=fel[1];
+ f1_el_z=fel[2];
+
+ int geometryIndex1 =
+ ( *bodies )
[id1]->geometricalModel->getClassIndex();
+ int geometryIndex2 =
+ ( *bodies )
[id2]->geometricalModel->getClassIndex();
+
+ if ( geometryIndex1 == geometryIndex2 )
+
+ {
+ BodyMacroParameters* de1 =
+
static_cast<BodyMacroParameters*> ( ( *bodies ) [id1]->physicalParameters.get()
);
+ x1 = de1->se3.position[0];
+ y1 = de1->se3.position[1];
+ z1 = de1->se3.position[2];
+
+
+ BodyMacroParameters* de2 =
+
static_cast<BodyMacroParameters*> ( ( *bodies ) [id2]->physicalParameters.get()
);
+ x2 = de2->se3.position[0];
+ y2 = de2->se3.position[1];
+ z2 = de2->se3.position[2];
+
+ ///Calcul des contraintes elastiques
spheres/spheres
+
+ sig11_el = sig11_el + f1_el_x* ( x2 - x1 );
+ sig22_el = sig22_el + f1_el_y* ( y2 - y1 );
+ sig33_el = sig33_el + f1_el_z* ( z2 - z1 );
+ sig12_el = sig12_el + f1_el_x* ( y2 - y1 );
+ sig13_el = sig13_el + f1_el_x* ( z2 - z1 );
+ sig23_el = sig23_el + f1_el_y* ( z2 - z1 );
+
+ }
+
+ else
+
+ {
+ Vector3r l =
+ std::min (
currentContactGeometry->radius2,
+
currentContactGeometry->radius1 )
+
*currentContactGeometry->normal;
+
+ /// Calcul des contraintes elastiques
spheres/parois
+
+ sig11_el = sig11_el + f1_el_x*l[0];
+ sig22_el = sig22_el + f1_el_y*l[1];
+ sig33_el = sig33_el + f1_el_z*l[2];
+ sig12_el = sig12_el + f1_el_x*l[1];
+ sig13_el = sig13_el + f1_el_x*l[2];
+ sig23_el = sig23_el + f1_el_y*l[2];
+
+ }
+
+ /// fabric tensor
+
+ Vector3r normal = currentContactGeometry->normal;
+
+ for ( int i=0; i<3; ++i )
+ {
+ for ( int n=0; n<3; ++n )
+ {
+ //fabricTensor[i][n]
+ FT[i][n]
+ += normal[i]*normal[n];
+ }
+ }
+
+ }
+ }
+ }
+}*/
+
+
+
YADE_PLUGIN();
Modified: trunk/pkg/dem/Engine/DeusExMachina/TriaxialStressController.hpp
===================================================================
--- trunk/pkg/dem/Engine/DeusExMachina/TriaxialStressController.hpp
2008-11-17 15:41:43 UTC (rev 1573)
+++ trunk/pkg/dem/Engine/DeusExMachina/TriaxialStressController.hpp
2008-11-17 15:48:37 UTC (rev 1574)
@@ -31,6 +31,7 @@
//int cachedForceClassIndex;
int ForceClassIndex;
Real previousStress, previousMultiplier; //previous mean stress
and size multiplier
+ bool firstRun;
public :
@@ -44,7 +45,7 @@
//! Stores the value of the translation at the previous time
step, stiffness, and normal
Vector3r previousTranslation [6];
//! The value of stiffness (updated according to
stiffnessUpdateInterval)
- Real stiffness [6];
+ vector<Real> stiffness;
Real strain [3];
Real volumetricStrain;
Vector3r normal [6];
@@ -52,6 +53,12 @@
Vector3r stress [6];
Vector3r force [6];
Real meanStress;
+ //! Value of spheres volume (solid volume)
+ Real spheresVolume;
+ //! Value of box volume
+ Real boxVolume;
+ //! Sample porosity
+ Real porosity;
//Real UnbalancedForce;
Added: trunk/pkg/dem/Engine/StandAloneEngine/MicroMacroAnalyser.cpp
===================================================================
--- trunk/pkg/dem/Engine/StandAloneEngine/MicroMacroAnalyser.cpp
2008-11-17 15:41:43 UTC (rev 1573)
+++ trunk/pkg/dem/Engine/StandAloneEngine/MicroMacroAnalyser.cpp
2008-11-17 15:48:37 UTC (rev 1574)
@@ -0,0 +1,237 @@
+/*************************************************************************
+* Copyright (C) 2008 by Bruno Chareyre *
+* [EMAIL PROTECTED] *
+* *
+* This program is free software; it is licensed under the terms of the *
+* GNU General Public License v2 or later. See file LICENSE for details. *
+*************************************************************************/
+
+
+#include<yade/pkg-dem/BodyMacroParameters.hpp>
+#include<yade/pkg-dem/SpheresContactGeometry.hpp>
+
+#include<yade/pkg-dem/ElasticContactInteraction.hpp>
+
+#include<yade/core/Omega.hpp>
+#include<yade/core/MetaBody.hpp>
+#include<yade/pkg-common/Force.hpp>
+#include<yade/pkg-common/Momentum.hpp>
+#include<yade/core/PhysicalAction.hpp>
+
+#include <yade/pkg-common/InteractingSphere.hpp>
+
+#include "MicroMacroAnalyser.hpp"
+
+#include "TesselationWrapper.h"
+
+#include "KinematicLocalisationAnalyser.hpp"
+#include "TriaxialState.h"
+
+CREATE_LOGGER(MicroMacroAnalyser);
+
+MicroMacroAnalyser::MicroMacroAnalyser() : StandAloneEngine() ,
actionForce(new Force) , actionMomentum(new Momentum)
+{
+ actionForceIndex = actionForce->getClassIndex();
+ actionMomentumIndex = actionMomentum->getClassIndex();
+ analyser = shared_ptr<KinematicLocalisationAnalyser> (new
KinematicLocalisationAnalyser);
+ analyser->SetConsecutive (true);
+ analyser->SetNO_ZERO_ID (false);
+ interval = 100;
+ outputFile = "MicroMacroAnalysis";
+ stateFileName = "./snapshots/state";
+}
+
+
+void MicroMacroAnalyser::registerAttributes()
+{
+ REGISTER_ATTRIBUTE(interval);
+ REGISTER_ATTRIBUTE(outputFile);
+}
+
+void MicroMacroAnalyser::postProcessAttributes(bool deserializing)
+{
+ if(deserializing)
+ {
+ bool file_exists = std::ifstream (outputFile.c_str()); //if
file does not exist, we will write colums titles
+ ofile.open(outputFile.c_str(), std::ios::app);
+ if (!file_exists) ofile<<"iteration eps1w eps2w eps3w eps11g
eps22g eps33g eps12g eps13g eps23g"<< endl;
+ }
+}
+
+void MicroMacroAnalyser::action(MetaBody* ncb)
+{
+ //cerr << "MicroMacroAnalyser::action(MetaBody* ncb) (interval="<<
interval <<", iteration="<< Omega::instance().getCurrentIteration()<<")" <<
endl;
+ if (Omega::instance().getCurrentIteration() == 0) setState(ncb, 1);
+ else if (Omega::instance().getCurrentIteration() % interval == 0) {
+ setState(ncb, 2, true, true);
+ analyser->ComputeParticlesDeformation();
+ Tenseur_sym3 epsg ( analyser->grad_u_total );
+ ofile << Omega::instance().getCurrentIteration() <<
analyser->Delta_epsilon(1,1)<<" "<<analyser->Delta_epsilon(2,2)<<"
"<<analyser->Delta_epsilon(3,3)<<" "<<epsg(1,1)<<" "<<epsg(2,2)<< "
"<<epsg(3,3)<<" "<<epsg(1,2)<<" "<<epsg(1,3)<<" "<<epsg(2,3)<<endl;
+ analyser->SwitchStates();
+ }
+ //cerr << "ENDOF MicroMacro::action" << endl;
+}
+
+
+
+void MicroMacroAnalyser::setState ( MetaBody* ncb, unsigned int state, bool
saveStates, bool computeIncrement )
+{
+ LOG_INFO ("MicroMacroAnalyser::setState");
+ if ( !triaxialCompressionEngine )
+ {
+ vector<shared_ptr<Engine> >::iterator itFirst =
ncb->engines.begin();
+ vector<shared_ptr<Engine> >::iterator itLast =
ncb->engines.end();
+ for ( ;itFirst!=itLast; ++itFirst )
+ {
+ if ( ( *itFirst )->getClassName() ==
"TriaxialCompressionEngine" ) //|| (*itFirst)->getBaseClassName() ==
"TriaxialCompressionEngine")
+ {
+ LOG_DEBUG ( "stress controller engine found" );
+ triaxialCompressionEngine =
YADE_PTR_CAST<TriaxialCompressionEngine> ( *itFirst );
+ //triaxialCompressionEngine =
shared_ptr<TriaxialCompressionEngine> (static_cast<TriaxialCompressionEngine*>
( (*itFirst).get()));
+ }
+ }
+ if ( !triaxialCompressionEngine ) LOG_ERROR ( "stress
controller engine not found" );
+ }
+
+ shared_ptr<BodyContainer>& bodies = ncb->bodies;
+ TriaxialState* ts;
+ if ( state==1 ) ts = analyser->TS0;
+ else if ( state==2 ) ts = analyser->TS1;
+ else LOG_ERROR ( "state must be 1 or 2, instead of " << state );
+ TriaxialState& TS = *ts;
+
+ TS.reset();
+
+ long Ng = bodies->size();
+ //cerr << "Ng= " << Ng << endl;
+ //Statefile >> Ng;
+ //Real x, y, z, rad; //coordonn�es/rayon
+ //Real tx, ty, tz;
+ //Point pos;
+ TS.mean_radius=0;
+ //Vecteur trans, rot;
+ //Real rad; //coordonn�es/rayon
+
+ TS.grains.resize ( Ng );
+ //cerr << "Ngrains =" << Ng << endl;
+ //GrainIterator git= grains.begin();
+// git->id=0;
+// git->sphere = Sphere(CGAL::ORIGIN, 0);
+// git->translation = CGAL::NULL_VECTOR;
+// git->rotation = CGAL::NULL_VECTOR;
+
+ BodyContainer::iterator biBegin = bodies->begin();
+ BodyContainer::iterator biEnd = bodies->end();
+ BodyContainer::iterator bi = biBegin;
+ Ng = 0;
+
+
+ for ( ; bi!=biEnd ; ++bi )
+ {
+ body_id_t Idg = ( *bi )->getId();
+ TS.grains[Idg].id = Idg;
+
+ if ( !( *bi )->isDynamic ) TS.grains[Idg].isSphere = false;
+ else {//then it is a sphere (not a wall)
+ ++Ng;
+ const InteractingSphere* s =
YADE_CAST<InteractingSphere*> ( ( *bi )->interactingGeometry.get() );
+ const RigidBodyParameters* p =
YADE_CAST<RigidBodyParameters*> ( ( *bi )->physicalParameters.get() );
+ const Vector3r& pos = p->se3.position;
+ Real rad = s->radius;
+
+ TS.grains[Idg].sphere = Sphere ( Point (
p->se3.position[0],p->se3.position[1],p->se3.position[2] ), rad );
+// TS.grains[Idg].translation = trans;
+// grains[Idg].rotation = rot;
+ TS.box.base = Point ( min ( TS.box.base.x(),
pos.X()-rad ),
+ min (
TS.box.base.y(), pos.Y()-rad ),
+ min (
TS.box.base.z(), pos.Z()-rad ) );
+ TS.box.sommet = Point ( max ( TS.box.sommet.x(),
pos.X() +rad ),
+ max (
TS.box.sommet.y(), pos.Y() +rad ),
+ max (
TS.box.sommet.z(), pos.Z() +rad ) );
+ TS.mean_radius += TS.grains[Idg].sphere.weight();
+
+
+ }
+ }
+
+ TS.mean_radius /= Ng;//rayon moyen
+ LOG_INFO ( " loaded : " << Ng << " grains with mean radius = " <<
TS.mean_radius );
+
+ InteractionContainer::iterator ii =
ncb->transientInteractions->begin();
+ InteractionContainer::iterator iiEnd =
ncb->transientInteractions->end();
+ for ( ; ii!=iiEnd ; ++ii )
+ {
+ if ( ( *ii )->isReal )
+ {
+ TriaxialState::Contact *c = new TriaxialState::Contact;
+ TS.contacts.push_back ( c );
+ TriaxialState::VectorGrain& grains = TS.grains;
+ body_id_t id1 = ( *ii )->getId1();
+ body_id_t id2 = ( *ii )->getId2();
+
+ c->grain1 = & ( TS.grains[id1] );
+ c->grain2 = & ( TS.grains[id2] );
+ grains[id1].contacts.push_back ( c );
+ grains[id2].contacts.push_back ( c );
+ c->normal = Vecteur (
+ ( YADE_CAST<SpheresContactGeometry*> (
( *ii )->interactionGeometry.get() ) )->normal.X(),
+ ( YADE_CAST<SpheresContactGeometry*> (
( *ii )->interactionGeometry.get() ) )->normal.Y(),
+ ( YADE_CAST<SpheresContactGeometry*> (
( *ii )->interactionGeometry.get() ) )->normal.Z() );
+// c->normal = (
grains[id2].sphere.point()-grains[id1].sphere.point() );
+// c->normal = c->normal/sqrt ( pow ( c->normal.x(),2 )
+pow ( c->normal.y(),2 ) +pow ( c->normal.z(),2 ) );
+ c->position = Vecteur (
+ ( YADE_CAST<SpheresContactGeometry*> (
( *ii )->interactionGeometry.get() ) )->contactPoint.X(),
+ ( YADE_CAST<SpheresContactGeometry*> (
( *ii )->interactionGeometry.get() ) )->contactPoint.Y(),
+ ( YADE_CAST<SpheresContactGeometry*> (
( *ii )->interactionGeometry.get() ) )->contactPoint.Z() );
+// c->position = 0.5* ( (
grains[id1].sphere.point()-CGAL::ORIGIN ) +
+// (
grains[id1].sphere.weight() *c->normal ) +
+// (
grains[id2].sphere.point()-CGAL::ORIGIN ) -
+// (
grains[id2].sphere.weight() *c->normal ) );
+
+
+ c->fn = YADE_CAST<ElasticContactInteraction*> ( ( ( *ii
)->interactionPhysics.get() ) )->normalForce.Dot ( (
YADE_CAST<SpheresContactGeometry*> ( ( *ii )->interactionGeometry.get() )
)->normal );
+ Vector3r fs = YADE_CAST<ElasticContactInteraction*> ( (
*ii )->interactionPhysics.get() )->shearForce;
+ c->fs = Vecteur ( fs.X(),fs.Y(),fs.Z() );
+ c->old_fn = c->fn;
+ c->old_fs = c->fs;
+ c->frictional_work = 0;
+ }
+ }
+
+ //Load various parameters
+
+ //rfric = find_parameter("rfric=", Statefile);// � remettre quand les
fichiers n'auront plus l'espace de trop...
+// Eyn = find_parameter("Eyn=", Statefile);
+// Eys = find_parameter("Eys=", Statefile);
+ TS.wszzh =
triaxialCompressionEngine->stress[triaxialCompressionEngine->wall_top][1];//find_parameter("wszzh=",
Statefile);
+ TS.wsxxd =
triaxialCompressionEngine->stress[triaxialCompressionEngine->wall_right][0];//find_parameter("wsxxd=",
Statefile);
+ TS.wsyyfa =
triaxialCompressionEngine->stress[triaxialCompressionEngine->wall_front][2];//find_parameter("wsyyfa=",
Statefile);
+ TS.eps3 =
triaxialCompressionEngine->strain[2];//find_parameter("eps3=", Statefile);
+ TS.eps1 =
triaxialCompressionEngine->strain[0];//find_parameter("eps1=", Statefile);
+ TS.eps2 =
triaxialCompressionEngine->strain[1];//find_parameter("eps2=", Statefile);
+
+ TS.haut = triaxialCompressionEngine->height;//find_parameter("haut=",
Statefile);
+ TS.larg = triaxialCompressionEngine->width;//find_parameter("larg=",
Statefile);
+ TS.prof = triaxialCompressionEngine->depth;//find_parameter("prof=",
Statefile);
+ TS.porom = analyser->ComputeMacroPorosity();//find_parameter("porom=",
Statefile);
+ TS.ratio_f = triaxialCompressionEngine-> ComputeUnbalancedForce ( ncb
);//find_parameter("ratio_f=", Statefile);
+// vit = find_parameter("vit=", Statefile);
+
+
+ if ( state == 2 && computeIncrement )
+ {
+ analyser->SetForceIncrements();
+ analyser->SetDisplacementIncrements();
+ }
+ if ( saveStates )
+ {
+ ostringstream oss;
+
oss<<stateFileName<<"_"<<Omega::instance().getCurrentIteration();
+ TS.to_file ( oss.str().c_str() );
+ }
+ cerr << "ENDOF MicroMacroAnalyser::setState" << endl;
+}
+
+
+
+YADE_PLUGIN();
Added: trunk/pkg/dem/Engine/StandAloneEngine/MicroMacroAnalyser.hpp
===================================================================
--- trunk/pkg/dem/Engine/StandAloneEngine/MicroMacroAnalyser.hpp
2008-11-17 15:41:43 UTC (rev 1573)
+++ trunk/pkg/dem/Engine/StandAloneEngine/MicroMacroAnalyser.hpp
2008-11-17 15:48:37 UTC (rev 1574)
@@ -0,0 +1,61 @@
+/*************************************************************************
+* Copyright (C) 2008 by Bruno Chareyre *
+* [EMAIL PROTECTED] *
+* *
+* This program is free software; it is licensed under the terms of the *
+* GNU General Public License v2 or later. See file LICENSE for details. *
+*************************************************************************/
+
+#ifndef MACRO_MICRO_ANALYSER_HPP
+#define MACRO_MICRO_ANALYSER_HPP
+
+#include<yade/core/StandAloneEngine.hpp>
+#include<yade/pkg-dem/TriaxialCompressionEngine.hpp>
+
+#include <set>
+#include <boost/tuple/tuple.hpp>
+#include <string>
+#include <fstream>
+
+/*! \brief Compute quantities like fabric tensor, local porosity, local
deformation, and other micromechanicaly defined quantities based on
triangulation/tesselation of the packing
+
+ This class is using a separate library built from extra/triangulation
sources
+ */
+
+class PhysicalAction;
+class KinematicLocalisationAnalyser;
+
+class MicroMacroAnalyser : public StandAloneEngine
+{
+/// Attributes
+ private :
+ shared_ptr<PhysicalAction> actionForce;
+ shared_ptr<PhysicalAction> actionMomentum;
+ int actionForceIndex;
+ int actionMomentumIndex;
+ std::ofstream ofile;
+
+ shared_ptr<TriaxialCompressionEngine> triaxialCompressionEngine;
+ shared_ptr<KinematicLocalisationAnalyser> analyser;
+ std::string outputFile;
+ std::string stateFileName;
+
+ public :
+ MicroMacroAnalyser();
+ void action(MetaBody*);
+ void setState(MetaBody* ncb, unsigned int state, bool
saveStates = false, bool computeIncrement = false);//Set current state as
initial (state=1) or final (state=2) congiguration for later kinematic analysis
on the increment; if requested : save snapshots (with specific format) -
possibly including contact forces increments on the state1->state2 interval
+ int interval;
+
+ DECLARE_LOGGER;
+
+ protected :
+ virtual void postProcessAttributes(bool deserializing);
+ void registerAttributes();
+ REGISTER_CLASS_NAME(MicroMacroAnalyser);
+ REGISTER_BASE_CLASS_NAME(StandAloneEngine);
+};
+
+REGISTER_SERIALIZABLE(MicroMacroAnalyser,false);
+
+#endif // MACRO_MICRO_ANALYZER_HPP
+
Property changes on:
trunk/pkg/dem/Engine/StandAloneEngine/MicroMacroAnalyser.hpp
___________________________________________________________________
Name: svn:executable
+ *
Modified: trunk/pkg/dem/Engine/StandAloneEngine/VolumicContactLaw.hpp
===================================================================
--- trunk/pkg/dem/Engine/StandAloneEngine/VolumicContactLaw.hpp 2008-11-17
15:41:43 UTC (rev 1573)
+++ trunk/pkg/dem/Engine/StandAloneEngine/VolumicContactLaw.hpp 2008-11-17
15:48:37 UTC (rev 1574)
@@ -45,6 +45,7 @@
VolumicContactLaw();
void action(MetaBody*);
+ void speedTest(MetaBody* ncb);
protected :
void registerAttributes();
_______________________________________________
Mailing list: https://launchpad.net/~yade-dev
Post to : [email protected]
Unsubscribe : https://launchpad.net/~yade-dev
More help : https://help.launchpad.net/ListHelp
