← Back to team overview

yade-dev team mailing list archive

[svn] r1574 - in trunk: extra/triangulation pkg/dem/Engine/DeusExMachina pkg/dem/Engine/StandAloneEngine

 

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                                  *
+*  bruno.chareyre@xxxxxxxxxxx                                            *
+*                                                                        *
+*  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                                  *
+*  bruno.chareyre@xxxxxxxxxxx                                            *
+*                                                                        *
+*  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();