DomainMultiScale Class Reference

#include <domain_multiscale.h>

Inheritance diagram for DomainMultiScale:

[legend]Collaboration diagram for DomainMultiScale:

[legend]List of all members.

Public Member Functions
int	build (char *config)
	This method build a full multiscale domain from a config file.
	DomainMultiScale (char *n)
Communicator &	getCommunicator ()
	return the global communicator object
DumperMultiScale &	getDumper ()
	return the global dumper object
double	GetEcin (int domtype, unsigned int id=0)
double	GetEcin ()
	virtual function to get kinetik energy
double	GetEpot (int domtype, unsigned int id=0)
double	GetEpot ()
	virtual function to get potential energy
double	GetMultiScaleEcin ()
double	GetMultiScaleEpot ()
DomainInterface *	model (unsigned int i)
	return a model from its registering order index
unsigned int	nb_models ()
	return the number of registered models
void	SaveSituation (int i)
	method that delegate the dump to restart file format to the used codes
void	Update ()
	perform a full step update
void	UpdateForces ()
	compute forces
void	UpdatePositions ()
	update positions
void	UpdateStuck ()
	correction induced by the registered coupling
void	UpdateVelocities ()
	update velocities
virtual	~DomainMultiScale ()
Private Member Functions
void	build_indexes ()
	generate mapping from models ID to registered order of the models
void	ParseLine (char *line)
	generic parser method that is called by the parser object on each red line
Private Attributes
Communicator *	communicateur
	global communicator object used to perform all communications
unsigned int	Dim
	dimension of the multiscale material (should be unified)
std::map< int, int >	dom_group
	mapping between IDs and communication group IDs
std::vector< int >	dom_indexes
	mapping between IDs and registered order
std::map< int, DomainInterface * >	dom_tab
	mapping between IDs and models
DumperMultiScale *	dumper
	global dumper object used to perform any dump of the multiscale material
StimulationMultiScale *	init_stimulation
	stimulations of the multiscale material performed before initial step
unsigned int	multi_step
	notificator of the multitimestep (not used at present time)
char	my_config [256]
	global config file
StimulationMultiScale *	permanent_stimulation
	stabilisation of Melh that need to be used at each timestep
std::vector< BridgingInterface * >	rec_tab
	vector of registered bridged zones
Friends
class	Parser

---

Detailed Description

Definition at line 58 of file domain_multiscale.h.

---

Constructor & Destructor Documentation

DomainMultiScale::DomainMultiScale

(

char *

n

)

Definition at line 74 of file domain_multiscale.cpp.

References dumper, init_stimulation, and multi_step.

                                          :
  DomainInterface(n,MULTISCALE,MULTISCALE)
{
  dumper = NULL;
  init_stimulation = NULL;
  multi_step = 1;
}

DomainMultiScale::~DomainMultiScale

(

)

[virtual]

Definition at line 56 of file domain_multiscale.cpp.

References build_indexes(), communicateur, DBG_INFO, dom_indexes, dom_tab, DUMP, dumper, init_stimulation, nb_models(), permanent_stimulation, and rec_tab.

                                   {
  delete dumper;
  delete init_stimulation;
  delete permanent_stimulation;

  for (unsigned int i = 0 ; i < nb_models() ; ++i){
    // here to build the dom_indexes just in case
    build_indexes();    
    DUMP("deleting domaine (ID=" << dom_indexes[i] << ") " << dom_tab[dom_indexes[i]],DBG_INFO);
    delete dom_tab[dom_indexes[i]];
  }
  
  for (unsigned int i = 0 ; i < rec_tab.size() ; ++i)
    delete rec_tab[i];  

  delete communicateur;
}

Here is the call graph for this function:

---

Member Function Documentation

int DomainMultiScale::build

(

char *

config

)

This method build a full multiscale domain from a config file.

Definition at line 264 of file domain_multiscale.cpp.

References communicateur, Dim, DUMP, dumper, FATAL, DumperMultiScale::Init(), init_stimulation, my_config, StimulationMultiScale::Stimulate(), and Communicator::Synchronize().

Referenced by main().

                                        {

  strncpy(my_config,config,255);

  if(world_size==1)
    communicateur = new UnityMPI();
//   else if (world_size>1){
// //   communicateur = new DistributedMPI(world_size);
// //   DOMAINECONTINU = 0;
// //   DOMAINEATOMIQUE = 1;
//     communicateur = new LinearMPI();
//     DOMAINECONTINU = communicateur->AddGroup(world_size);
//     //DOMAINEATOMIQUE = communicateur->AddGroup(world_size-world_size/2);
//     //    communicateur = new DistributedMPI(world_size);
//   }

  Parser::ParseConfigFile<DomainMultiScale>(config,"MultiScale",this);

  if (!communicateur){FATAL("COM keyword should be used in config file");}
  
  if (dumper)
    dumper->Init();
  
  if (init_stimulation)
    init_stimulation->Stimulate();

  communicateur->Synchronize();

#ifdef USING_EPSN
  int epsn_status = 0;
  // EPSN Ready  
  DUMP("EPSN is going to be READY...");
  epsn_status = epsn_itfc->ready();
  if (!epsn_status) {
    FATAL("error on  EPSN Node ready operation\n");
  }
  DUMP("EPSN READY");
  // the main loop
  DUMP("EPSN Begin HTG");
  epsn_itfc->beginHTM();
  epsn_itfc->beginLoop("main");
  DUMP("simulation ready to start for EPSN");
#endif

  return Dim;
}

Here is the call graph for this function:

void DomainMultiScale::build_indexes

(

)

[private]

generate mapping from models ID to registered order of the models

Definition at line 724 of file domain_multiscale.cpp.

References DBG_INFO, dom_indexes, dom_tab, and DUMP.

Referenced by model(), and ~DomainMultiScale().

                                    {
  if (dom_indexes.size()==0){
    /* create index for domains */
    map<int,DomainInterface *>::iterator courant = dom_tab.begin();
    map<int,DomainInterface *>::iterator dernier = dom_tab.end();
      
    while (courant != dernier){
      DUMP("pushing ID " << (*courant).first,DBG_INFO);
      dom_indexes.push_back((*courant).first);
      ++courant;
    }  
  }
}

Communicator& DomainMultiScale::getCommunicator

(

)

[inline]

return the global communicator object

Definition at line 104 of file domain_multiscale.h.

References communicateur.

                                  {
    return *communicateur;
  }

DumperMultiScale& DomainMultiScale::getDumper

(

)

[inline]

return the global dumper object

Definition at line 109 of file domain_multiscale.h.

References dumper, and FATAL.

Referenced by main().

                                {
    if (dumper == NULL) FATAL("multiscale dumper not created : critical this should not append, have forgotten DIMENSION keyword ?");
    return *dumper;
  }

double DomainMultiScale::GetEcin	(	int	domtype,
		unsigned int	id = 0
	)

Definition at line 94 of file domain_multiscale.cpp.

References DBG_WARNING, and DUMP.

                                                                {
//   if (domaine_type == DOMAINEATOMIQUE)
//     return domA_tab[i]->GetEcin();
//   if (domaine_type == DOMAINECONTINU)
//     return domC_tab[i]->GetEcin();

  DUMP("without effect for the moment"  << domaine_type << " " << i,DBG_WARNING);
  return 0;
}

double DomainMultiScale::GetEcin

(

)

[inline, virtual]

virtual function to get kinetik energy

Implements DomainInterface.

Definition at line 67 of file domain_multiscale.h.

{return 0.0;};

double DomainMultiScale::GetEpot	(	int	domtype,
		unsigned int	id = 0
	)

Definition at line 116 of file domain_multiscale.cpp.

References DBG_WARNING, and DUMP.

                                                                {

//   if (domaine_type == DOMAINEATOMIQUE)
//     if (communicateur->amIinGroup(DOMAINEATOMIQUE)){ 
//       return domA_tab[i]->GetEpot();
//     }
//   if (domaine_type == DOMAINECONTINU)
//     if (communicateur->amIinGroup(DOMAINECONTINU)){ 
//       return domC_tab[i]->GetEpot();
//     }
  DUMP("without effect for the moment " << domaine_type << " " << i,DBG_WARNING);
  return 0;
}

double DomainMultiScale::GetEpot

(

)

[inline, virtual]

virtual function to get potential energy

Implements DomainInterface.

Definition at line 68 of file domain_multiscale.h.

{return 0.0;};

double DomainMultiScale::GetMultiScaleEcin

(

)

Definition at line 83 of file domain_multiscale.cpp.

References DBG_WARNING, and DUMP.

                                           {
//   if (communicateur->amIinGroup(DOMAINEATOMIQUE))
//     return GetEcin(DOMAINEATOMIQUE);
  
//   if (communicateur->amIinGroup(DOMAINECONTINU))
//     return GetEcin(DOMAINECONTINU);

  DUMP("without effect for the moment",DBG_WARNING);
  return 0; 
}

double DomainMultiScale::GetMultiScaleEpot

(

)

Definition at line 104 of file domain_multiscale.cpp.

References DBG_WARNING, and DUMP.

                                           {
//   if (communicateur->amIinGroup(DOMAINEATOMIQUE)){
//     return GetEpot(DOMAINEATOMIQUE);
//   }
  
//   if (communicateur->amIinGroup(DOMAINECONTINU)){
//     return GetEpot(DOMAINECONTINU);
//   }
  DUMP("without effect for the moment",DBG_WARNING);
  return 0; 
}

DomainInterface* DomainMultiScale::model

(

unsigned int

i

)

[inline]

return a model from its registering order index

Definition at line 93 of file domain_multiscale.h.

References build_indexes(), dom_indexes, and dom_tab.

Referenced by DumperMultiScale::CreateDumper(), and StimulationMultiScale::CreateStimulation().

                                         {
    build_indexes();
    return dom_tab[dom_indexes[i]];
  };

Here is the call graph for this function:

unsigned int DomainMultiScale::nb_models

(

)

[inline]

return the number of registered models

Definition at line 99 of file domain_multiscale.h.

References dom_tab.

Referenced by DumperMultiScale::CreateDumper(), StimulationMultiScale::CreateStimulation(), and ~DomainMultiScale().

                          {
    return dom_tab.size();
  };

void DomainMultiScale::ParseLine

(

char *

line

)

[private]

generic parser method that is called by the parser object on each red line

Definition at line 311 of file domain_multiscale.cpp.

References _BELYTSCHKO, _BELYTSCHKO_FULL, _DUMMY, _FORMEFAIBLE, _LAMMPS, _LEAST_SQUARE, _LIBMESH, _MD1D, _MYMETHOD, _STAMP, Communicator::AddGroup(), UnitsConverter::AtomsUnits, MaterialContinuumInterface::AutoConfig(), BridgingInterface::build(), DomainContinuumInterface::build(), DomainAtomicInterface::build(), communicateur, UnitsConverter::ComputeEtalon(), DumperMultiScale::CreateDumper(), StimulationMultiScale::CreateStimulation(), DBG_DETAIL, DBG_INFO_STARTUP, DBG_WARNING, DEPGAUSS, DEPUNI, Dim, DISLOEDGE, dom_group, dom_tab, DUMP, dumper, DUMPER1D, DUMPERECIN, DUMPEREPSN, DUMPERFIG, DUMPERLAMMPS, DUMPERPARAVIEW, DUMPERRESTART, DUMPERSCOTCH, DUMPERTEXT, DUMPERVGROUPE, DUMPERXYZ, FATAL, DomainAtomicInterface::Geom(), DumperMultiScale::getDumper(), DomainContinuumInterface::getMaterial(), StimulationMultiScale::GetStimulation(), DomainInterface::ID, IMPULSE, BridgingInterface::Init(), init_stimulation, MATIERELANCEE, MODULATE, my_config, Parser::parse_geometrie(), Parser::parseDouble(), Parser::parseEntier(), Parser::parseMetre(), permanent_stimulation, RAZ, rec_tab, BridgingInterface::SetName(), DumperInterface::SetParam(), StimulationInterface::SetParam(), BridgingInterface::SetParam(), DumperInterface::SetPrefix(), SINUSOIDE, STABILISE, Parser::strNext(), UnitsConverter::unit_code, and VELGAUSS.

{
  char mot[256];

  int ID;
  line += Parser::strNext(mot,line);

  //analyse de la valeur en fonction du switch
  if(!strcmp(mot,"MD_CODE")){
    char md_config[255];
    unsigned int md_code=_STAMP;

    DUMP("parsing MD_CODE commande = " << line,DBG_INFO_STARTUP);
    line+=Parser::strNext(mot,line);

    if(!strcmp(mot,"STAMP"))
      md_code = _STAMP;
    else if(!strcmp(mot,"LAMMPS"))
      md_code = _LAMMPS;
    else if(!strcmp(mot,"MD1D"))
      md_code = _MD1D;
    else if(!strcmp(mot,"DUMMY"))
      md_code = _DUMMY;

    line+=Parser::parseEntier(ID,line);    
    line+=Parser::strNext(md_config,line);
    if (md_config[0] == '\0')
      strcpy(md_config,my_config);

    if (world_size == 1)
      dom_group[ID] = 0;

    if (dom_group.count(ID) == 0)
      {FATAL("PROCESSOR KEYWORD SHOULD BE USED ON ID " << ID);}
    dom_tab[ID] = DomainAtomicInterface::build(md_config,md_code,*communicateur,ID,dom_group[ID]);
    if (dom_tab[ID] == NULL)
      {FATAL("pas bon");}

    DUMP("registered domain (ID=" << ID << ")  " << dom_tab[ID],DBG_WARNING);
  }
  else if(!strcmp(mot,"ELAST_CODE")){
    char elast_config[255];
    unsigned int elast_code;

    DUMP("parsing ELAST_CODE commande = " << line,DBG_INFO_STARTUP);
    line+=Parser::strNext(mot,line);
    
    if(!strcmp(mot,"LIBMESH"))
      elast_code = _LIBMESH;

    line+=Parser::parseEntier(ID,line);    
    line+=Parser::strNext(elast_config,line);
    if (elast_config[0] == '\0')
      strcpy(elast_config,my_config);

    if (world_size == 1)
      dom_group[ID] = 0;

    if (dom_group.count(ID) == 0)
      {FATAL("PROCESSOR KEYWORD SHOULD BE USED ON ID " << ID);}  
    dom_tab[ID] = DomainContinuumInterface::build(elast_config,Dim,*communicateur,ID,dom_group[ID]);
    //    dom_ID[nb_materials] = ID;
    DUMP("a continu model as been with ID " << ID << " has been created",DBG_WARNING);
  }
  else if(!strcmp(mot,"BRIDGING_CODE")){

    BridgingInterface * rec;  
    DomainAtomicInterface * domA;
    DomainContinuumInterface * domC;
    double param;

    int bridging_code=_BELYTSCHKO,IDMD,IDC,geomID;

    DUMP("parsing BRIDGING_CODE commande = " << line,DBG_INFO_STARTUP);
    line+=Parser::strNext(mot,line);
    
    if(!strcmp(mot,"BELYTSCHKO"))
      bridging_code = _BELYTSCHKO;

    if(!strcmp(mot,"BELYTSCHKOFULL"))
      bridging_code = _BELYTSCHKO_FULL;

    if(!strcmp(mot,"FORMEFAIBLE"))
      bridging_code = _FORMEFAIBLE;

    if(!strcmp(mot,"LEASTSQUARE"))
      bridging_code = _LEAST_SQUARE;

    if(!strcmp(mot,"MYMETHOD"))
      bridging_code = _MYMETHOD;


    line+=Parser::parseEntier(IDMD,line);
    line+=Parser::parseEntier(IDC,line);
    line+=Parser::parseEntier(geomID,line);




    domA = static_cast<DomainAtomicInterface *>(dom_tab[IDMD]);
    domC = static_cast<DomainContinuumInterface *>(dom_tab[IDC]);

    rec = BridgingInterface::build(bridging_code,*domA,*domC,geomID,Dim,*communicateur);
    
    int lu = Parser::strNext(mot,line);

    while (lu){
      line += lu;
      line+=Parser::parseDouble(param,line);      
      DUMP("parsing key " << mot << " value = " << param << " nb de rec = " << rec_tab.size(),DBG_WARNING);
      rec->SetParam(mot,param);  
      lu = Parser::strNext(mot,line);
      DUMP("lu = " << lu,DBG_DETAIL);
    }
    
    char recname[256];
    sprintf(recname,"bridge-%d",(int)rec_tab.size());
    rec->SetName(recname);

    rec->Init();
    rec_tab.push_back(rec);
    //    ++nb_recouvrement;

  }
  else if(!strcmp(mot,"AUTOCONFIG")){
    double tmesh;
    double padSize;
    int IDMD,IDC;
    DomainContinuumInterface * domC;
    DomainAtomicInterface * domA;

    DUMP("parsing AUTOCONFIG commande = " << line,DBG_INFO_STARTUP);

    line+=Parser::parseEntier(IDMD,line);
    line+=Parser::parseEntier(IDC,line);

    line+=Parser::parseMetre(tmesh,line);
    line+=Parser::parseMetre(padSize,line);
    
    domC = static_cast<DomainContinuumInterface *>(dom_tab[IDC]);
    domA = static_cast<DomainAtomicInterface *>(dom_tab[IDMD]);

    domC->getMaterial().AutoConfig(domA->Geom(),tmesh,padSize);
  }
  else if(!strcmp(mot,"DIMENSION")){
    line+=Parser::parseEntier((int &)Dim,line);
    DUMP("parsing DIMENSION commande = " << Dim,DBG_INFO_STARTUP);
    dumper = new DumperMultiScale(*this,Dim);
    init_stimulation = new StimulationMultiScale(*this,Dim);
    permanent_stimulation = new StimulationMultiScale(*this,Dim);
  }
  else if(!strcmp(mot,"STIMULATION")){
    line+=Parser::strNext(mot,line);
    
    if(!strcmp(mot,"GAUSS")){
      DUMP("parsing STIMULATION commande = " << line,DBG_INFO_STARTUP);
      double LWave,Intensity;
      line+=Parser::parseMetre(LWave,line);
      line+=Parser::parseMetre(Intensity,line);
      int bID = Parser::parse_geometrie(line);
      if (bID == -1){FATAL("Geometrie could not be parsed for keyword STIMULATIONGAUSS");}
      if (!init_stimulation){FATAL("DIMENSION KEYWORD SHOULD BE USED BEFORE IN CONFIG FILE");}
      std::vector<int> stim_indexes = init_stimulation->CreateStimulation(DEPGAUSS,Intensity,bID);
      for (unsigned k = 0 ; k < stim_indexes.size() ; ++k)
        init_stimulation->GetStimulation(stim_indexes[k])->SetParam("LWave",LWave);

      int lu = Parser::strNext(mot,line);
      double param;
      if (lu>0)
        if (!strcmp(mot,"Direction")){
          line += lu;
          line+=Parser::parseDouble(param,line);
          stim_indexes = init_stimulation->CreateStimulation(VELGAUSS,Intensity,bID);
          for (unsigned k = 0 ; k < stim_indexes.size() ; ++k){
            init_stimulation->GetStimulation(stim_indexes[k])->SetParam("LWave",LWave);
            init_stimulation->GetStimulation(stim_indexes[k])->SetParam("Direction",param);
          }
        }
    }
    else if(!strcmp(mot,"IMPULSE")){
      double direction;
      DUMP("parsing STIMULATION commande = " << line,DBG_INFO_STARTUP);
      double LWave,Intensity;
      line+=Parser::parseMetre(LWave,line);
      line+=Parser::parseMetre(Intensity,line);
      line+=Parser::parseDouble(direction,line);
      int bID = Parser::parse_geometrie(line);
      if (bID == -1){FATAL("Geometrie could not be parsed for keyword STIMULATIONGAUSS");}
      if (!init_stimulation){FATAL("DIMENSION KEYWORD SHOULD BE USED BEFORE IN CONFIG FILE");}
      std::vector<int> stim_indexes = init_stimulation->CreateStimulation(IMPULSE,Intensity,bID);
      for (unsigned k = 0 ; k < stim_indexes.size() ; ++k){
        init_stimulation->GetStimulation(stim_indexes[k])->SetParam("LWave",LWave);
        init_stimulation->GetStimulation(stim_indexes[k])->SetParam("Direction",direction);
      }
    }
    else if(!strcmp(mot,"DISLOEDGE")){
      double direction;
      DUMP("parsing STIMULATION commande = " << line,DBG_INFO_STARTUP);
      double burgers,posx,posy,epsilonxy,width=0;
      line+=Parser::parseMetre(burgers,line);
      line+=Parser::parseMetre(width,line);
      line+=Parser::parseMetre(posx,line);
      line+=Parser::parseMetre(posy,line);
      line+=Parser::parseDouble(epsilonxy,line);
      int bID = Parser::parse_geometrie(line);
      if (bID == -1){FATAL("Geometrie could not be parsed for keyword STIMULATIONGAUSS");}
      if (!init_stimulation){FATAL("DIMENSION KEYWORD SHOULD BE USED BEFORE IN CONFIG FILE");}
      std::vector<int> stim_indexes = init_stimulation->CreateStimulation(DISLOEDGE,width,bID);
      for (unsigned k = 0 ; k < stim_indexes.size() ; ++k){
        init_stimulation->GetStimulation(stim_indexes[k])->SetParam("BURGERS",burgers);
        init_stimulation->GetStimulation(stim_indexes[k])->SetParam("POSX",posx);
        init_stimulation->GetStimulation(stim_indexes[k])->SetParam("POSY",posy);
        init_stimulation->GetStimulation(stim_indexes[k])->SetParam("EPSILONXY",epsilonxy);
      }
    }


    if(!strcmp(mot,"MODULATE")){
      DUMP("parsing STIMULATION commande = " << line,DBG_INFO_STARTUP);
      double LWave,Intensity;
      line+=Parser::parseMetre(LWave,line);
      line+=Parser::parseDouble(Intensity,line);
      int bID = Parser::parse_geometrie(line);
      if (!init_stimulation){FATAL("DIMENSION KEYWORD SHOULD BE USED BEFORE IN CONFIG FILE");}
      std::vector<int> stim_indexes = init_stimulation->CreateStimulation(MODULATE,Intensity,bID);
      for (unsigned k = 0 ; k < stim_indexes.size() ; ++k)
        init_stimulation->GetStimulation(stim_indexes[k])->SetParam("LWave",LWave);
    }
    if(!strcmp(mot,"UNI")){
      DUMP("parsing STIMULATION commande = " << line,DBG_INFO_STARTUP);
      double Intensity;
      line+=Parser::parseMetre(Intensity,line);

      int bID = Parser::parse_geometrie(line);
      if (bID == -1){FATAL("Geometrie could not be parsed for keyword STIMULATIONGAUSS");}
      if (!init_stimulation){FATAL("DIMENSION KEYWORD SHOULD BE USED BEFORE IN CONFIG FILE");}
      std::vector<int> stim_indexes = init_stimulation->CreateStimulation(DEPUNI,Intensity,bID);
     
      double param;

      int lu = Parser::strNext(mot,line);
      while (lu){
        line += lu;
        line+=Parser::parseDouble(param,line);      
        DUMP("parsing key " << mot << " value = " << param,DBG_INFO_STARTUP);
        for (unsigned k = 0 ; k < stim_indexes.size() ; ++k)
          init_stimulation->GetStimulation(stim_indexes[k])->SetParam(mot,param);
        lu = Parser::strNext(mot,line);
        DUMP("lu = " << lu,DBG_INFO_STARTUP);
      }
    }
    else if(!strcmp(mot,"SIN")){
      DUMP("parsing STIMULATION commande = " << line,DBG_INFO_STARTUP);
      double LWave,Intensity;
      line+=Parser::parseMetre(LWave,line);
      line+=Parser::parseMetre(Intensity,line);
      int bID = Parser::parse_geometrie(line);
      if (!init_stimulation){FATAL("DIMENSION KEYWORD SHOULD BE USED BEFORE IN CONFIG FILE");}
      std::vector<int> stim_indexes = init_stimulation->CreateStimulation(SINUSOIDE,Intensity,bID);
      for (unsigned k = 0 ; k < stim_indexes.size() ; ++k)
        init_stimulation->GetStimulation(stim_indexes[k])->SetParam("LWave",LWave);
    }
    else if(!strcmp(mot,"RAZ")){
      DUMP("parsing STIMULATION commande = " << mot << " " << line,DBG_INFO_STARTUP);
      int bID = Parser::parse_geometrie(line);
      if (!init_stimulation){FATAL("DIMENSION KEYWORD SHOULD BE USED BEFORE IN CONFIG FILE");}
      int lu = Parser::strNext(mot,line);
      int freq = 1;
      if (lu && strcmp(mot,"FREQ")==0) {
        line += lu;
        line += Parser::parseEntier(freq,line);
        DUMP("parsing FREQ commande " << freq,DBG_INFO_STARTUP);
      }
      permanent_stimulation->CreateStimulation(RAZ,0,bID,freq);
    }
    else if(!strcmp(mot,"MATIERELANCEE")){
      DUMP("parsing STIMULATION commande = " << mot << " " << line,DBG_INFO_STARTUP);
      double intensity;
      double Axe;
      line += Parser::parseDouble(Axe,line);
      line += Parser::parseDouble(intensity,line);
      int bID = Parser::parse_geometrie(line);
      if (bID == -1){FATAL("je n'ai pas pu parser la geometrie pour matiere lancee !!");}
      if (!init_stimulation){FATAL("DIMENSION KEYWORD SHOULD BE USED BEFORE IN CONFIG FILE");}
      std::vector<int> stim_indexes = init_stimulation->CreateStimulation(MATIERELANCEE,intensity,bID);
      for (unsigned k = 0 ; k < stim_indexes.size() ; ++k)
        init_stimulation->GetStimulation(stim_indexes[k])->SetParam("Axe",Axe);
    }
    else if(!strcmp(mot,"STABILISE")){
       DUMP("parsing STIMULATION commande = " << mot,DBG_INFO_STARTUP);
       int lu = Parser::strNext(mot,line);
       int freq = 1;
       if (lu && strcmp(mot,"FREQ")==0) {
        line += lu;
        line += Parser::parseEntier(freq,line);
       }


       permanent_stimulation->CreateStimulation(STABILISE,0,-1,freq);
    }
    else if(!strcmp(mot,"DISLOEDGEBORDERS")){
      double direction;
      DUMP("parsing STIMULATION commande = " << line,DBG_INFO_STARTUP);
      double burgers,posx,posy,epsilonxy,width=0;
      line+=Parser::parseMetre(burgers,line);
      line+=Parser::parseMetre(width,line);
      line+=Parser::parseMetre(posx,line);
      line+=Parser::parseMetre(posy,line);
      line+=Parser::parseDouble(epsilonxy,line);
      int bID = Parser::parse_geometrie(line);
      if (bID == -1){FATAL("Geometrie could not be parsed for keyword STIMULATIONGAUSS");}
      if (!permanent_stimulation){FATAL("DIMENSION KEYWORD SHOULD BE USED BEFORE IN CONFIG FILE");}
      std::vector<int> stim_indexes = permanent_stimulation->CreateStimulation(DISLOEDGE,width,bID);
      for (unsigned k = 0 ; k < stim_indexes.size() ; ++k){
        permanent_stimulation->GetStimulation(stim_indexes[k])->SetParam("BURGERS",burgers);
        permanent_stimulation->GetStimulation(stim_indexes[k])->SetParam("POSX",posx);
        permanent_stimulation->GetStimulation(stim_indexes[k])->SetParam("POSY",posy);
        permanent_stimulation->GetStimulation(stim_indexes[k])->SetParam("EPSILONXY",epsilonxy);
      }
    }
  }
  else if(!strcmp(mot,"UNITCODE")){
    DUMP("parsing UNITCODE commande = " << line,DBG_INFO_STARTUP);
    line+=Parser::strNext(mot,line);
    if (!strcmp(mot,"AtomsUnits"))
      UnitsConverter::unit_code = UnitsConverter::AtomsUnits;

    UnitsConverter::ComputeEtalon();
  }
  else if(!strcmp(mot,"PROCESSORS")){
    line+=Parser::strNext(mot,line);
    int id = atoi(mot);
    DUMP("id = " << id,DBG_INFO_STARTUP);
    line+=Parser::strNext(mot,line);
    int nb_procs = atoi(mot);
    DUMP("nb_procs = " << nb_procs,DBG_INFO_STARTUP);
    dom_group[id] = communicateur->AddGroup(nb_procs);
    DUMP("model ID "  << id << " got communication group " << dom_group[id],DBG_INFO_STARTUP);
  }
  else if(!strcmp(mot,"COM")){
    if (world_size==1)return;
    line+=Parser::strNext(mot,line);
    if (!strcmp(mot,"DISTRIBUTED")){
      communicateur = new LinearMPI();
    }    
  }
  else if(!strcmp(mot,"DUMPER")){
    char freq[255];

    std::vector<int> dump_indexes;

    DUMP("parsing DUMPER commande = " << line,DBG_INFO_STARTUP);
    line+=Parser::strNext(mot,line);
    line+=Parser::strNext(freq,line);
    int frequency = atoi(freq);
    DUMP("frequency injected = " << frequency,DBG_INFO_STARTUP);
    if (!dumper){FATAL("DIMENSION KEYWORD SHOULD BE USED BEFORE IN CONFIG FILE");}
    if (!strcmp(mot,"PARAVIEW"))
      dump_indexes = dumper->CreateDumper(DUMPERPARAVIEW,frequency);
    else if (!strcmp(mot,"TEXT"))
      dump_indexes = dumper->CreateDumper(DUMPERTEXT,frequency);
    else if (!strcmp(mot,"DUMPER1D"))
      dump_indexes = dumper->CreateDumper(DUMPER1D,frequency);
    else if (!strcmp(mot,"DUMPERVGROUPE"))
      dump_indexes = dumper->CreateDumper(DUMPERVGROUPE,frequency);
    else if (!strcmp(mot,"DUMPERECIN"))
      dump_indexes = dumper->CreateDumper(DUMPERECIN,frequency);
    else if (!strcmp(mot,"SCOTCH"))
      dump_indexes = dumper->CreateDumper(DUMPERSCOTCH,frequency);
#ifdef USING_FIG
    else if (!strcmp(mot,"FIG"))
      dump_indexes = dumper->CreateDumper(DUMPERFIG,frequency);
#endif
    else if (!strcmp(mot,"LAMMPS"))
      dump_indexes = dumper->CreateDumper(DUMPERLAMMPS,frequency);
    else if (!strcmp(mot,"XYZ"))
      dump_indexes = dumper->CreateDumper(DUMPERXYZ,frequency);
#ifdef USING_EPSN
    else if (!strcmp(mot,"EPSN")){
      line+=Parser::strNext(mot,line);
      dump_indexes = dumper->CreateDumper(DUMPEREPSN,frequency);
      strncpy(xmlepsnfile,mot,255);
    }
#endif //USING_EPSN
    else if (!strcmp(mot,"RESTART")){
      dump_indexes = dumper->CreateDumper(DUMPERRESTART,frequency);
    }
    else{FATAL("Unknown dumper : " << mot);}
    DUMP("dumpers instanciated ... ",DBG_INFO_STARTUP);
    while (strlen(mot)>0){
      double value = 1;
      
      line+=Parser::strNext(mot,line);
      if(!strcmp(mot,"FILTERDISP") || !strcmp(mot,"FILTERGEOM") 
         || !strcmp(mot,"FILTERFORCE") || !strcmp(mot,"FILTERVEL")){
        line+=Parser::parseDouble(value,line);
      }
      if(!strcmp(mot,"PREFIX")){
        char prefix[500];
        line+=Parser::strNext(prefix,line);
        for (unsigned k = 0 ; k < dump_indexes.size() ; ++k)
          dumper->getDumper(dump_indexes[k])->SetPrefix(prefix);
        continue;
      }
      for (unsigned k = 0 ; k < dump_indexes.size() ; ++k)
        dumper->getDumper(dump_indexes[k])->SetParam(mot,value);
    }
    DUMP("dumpers configured ... ",DBG_INFO_STARTUP);
  }

 
}

Here is the call graph for this function:

void DomainMultiScale::SaveSituation

(

int

i

)

[virtual]

method that delegate the dump to restart file format to the used codes

Implements DomainInterface.

Definition at line 130 of file domain_multiscale.cpp.

References Communicator::amIinGroup(), communicateur, dom_group, dom_tab, STARTTIMER, and STOPTIMER.

                                             {

  map<int,DomainInterface *>::iterator courant = dom_tab.begin();
  map<int,DomainInterface *>::iterator dernier = dom_tab.end();

  STARTTIMER("Saving Situation");       
  while (courant != dernier){
    if (communicateur->amIinGroup(dom_group[(*courant).first]))
      (*courant).second->SaveSituation(index);
  }
  STOPTIMER("Saving Situation");

}

Here is the call graph for this function:

void DomainMultiScale::Update

(

)

perform a full step update

a full explicit step is normally composed of a position update, a force computation, a velocity update, and an eventual coupling correction

Definition at line 145 of file domain_multiscale.cpp.

References Communicator::amIinGroup(), communicateur, dom_group, dom_tab, rec_tab, STARTTIMER, and STOPTIMER.

                             {

  map<int,DomainInterface *>::iterator courant = dom_tab.begin();
  map<int,DomainInterface *>::iterator dernier = dom_tab.end();
  
  STARTTIMER("FullStep");       
  while (courant != dernier){
    if (communicateur->amIinGroup(dom_group[(*courant).first]))
      {

        (*courant).second->UpdatePositions();
        (*courant).second->UpdateForces();      
        (*courant).second->UpdateVelocities();
      }
    ++courant;
  }
  
  for (unsigned int i = 0 ; i < rec_tab.size() ; ++i)
    rec_tab[i]->Stucking();
  
  STOPTIMER("FullStep");
}

Here is the call graph for this function:

void DomainMultiScale::UpdateForces

(

)

[virtual]

compute forces

Implements DomainInterface.

Definition at line 221 of file domain_multiscale.cpp.

References Communicator::amIinGroup(), communicateur, dom_group, dom_tab, permanent_stimulation, STARTTIMER, StimulationMultiScale::Stimulate(), and STOPTIMER.

Referenced by main().

                                    {
#ifdef USING_EPSN
  if (epsn_itfc->isNodeInitialized())
    epsn_itfc->beginTask("updateforces");
#endif

  map<int,DomainInterface *>::iterator courant = dom_tab.begin();
  map<int,DomainInterface *>::iterator dernier = dom_tab.end();


  STARTTIMER("StepForces");     
  while (courant != dernier){
    if (communicateur->amIinGroup(dom_group[(*courant).first]))
      (*courant).second->UpdateForces();
    ++courant;
  }
  STOPTIMER("StepForces");

  STARTTIMER("StabiliseStimulations");
  permanent_stimulation->Stimulate();
  STOPTIMER("StabiliseStimulations");

#ifdef USING_EPSN
  if (epsn_itfc->isNodeInitialized())
    epsn_itfc->endTask("updateforces");
#endif
}

Here is the call graph for this function:

void DomainMultiScale::UpdatePositions

(

)

[virtual]

update positions

Implements DomainInterface.

Definition at line 169 of file domain_multiscale.cpp.

References Communicator::amIinGroup(), communicateur, dom_group, dom_tab, STARTTIMER, and STOPTIMER.

Referenced by main().

                                       {
#ifdef USING_EPSN
  if (epsn_itfc->isNodeInitialized())
    epsn_itfc->beginTask("updatepositions");
#endif

  map<int,DomainInterface *>::iterator courant = dom_tab.begin();
  map<int,DomainInterface *>::iterator dernier = dom_tab.end();

  STARTTIMER("StepPositions");  
  while (courant != dernier){
    if (communicateur->amIinGroup(dom_group[(*courant).first])){
      (*courant).second->UpdatePositions();
    }
    
    ++courant;
  }
  STOPTIMER("StepPositions");

#ifdef USING_EPSN
  if (epsn_itfc->isNodeInitialized())
    epsn_itfc->endTask("updatepositions");
#endif

}

Here is the call graph for this function:

void DomainMultiScale::UpdateStuck

(

)

correction induced by the registered coupling

Definition at line 249 of file domain_multiscale.cpp.

References rec_tab.

Referenced by main().

                                  {
#ifdef USING_EPSN
  if (epsn_itfc->isNodeInitialized())
    epsn_itfc->beginTask("updatecoupling");
#endif

  for (unsigned int i=0; i < rec_tab.size(); ++i)
    rec_tab[i]->Stucking();

#ifdef USING_EPSN
  if (epsn_itfc->isNodeInitialized())
    epsn_itfc->endTask("updatecoupling");
#endif
}

void DomainMultiScale::UpdateVelocities

(

)

[virtual]

update velocities

Implements DomainInterface.

Definition at line 196 of file domain_multiscale.cpp.

References Communicator::amIinGroup(), communicateur, dom_group, dom_tab, STARTTIMER, and STOPTIMER.

Referenced by main().

                                        {
#ifdef USING_EPSN
  if (epsn_itfc->isNodeInitialized())
    epsn_itfc->beginTask("updatevelocities");
#endif

  map<int,DomainInterface *>::iterator courant = dom_tab.begin();
  map<int,DomainInterface *>::iterator dernier = dom_tab.end();

  STARTTIMER("StepVelocities"); 
  while (courant != dernier){
    if (communicateur->amIinGroup(dom_group[(*courant).first]))
      (*courant).second->UpdateVelocities();
    ++courant;
  }
  STOPTIMER("StepVelocities");
  
#ifdef USING_EPSN
  if (epsn_itfc->isNodeInitialized())
    epsn_itfc->endTask("updatevelocities");
#endif

}

Here is the call graph for this function:

---

Friends And Related Function Documentation

friend class Parser [friend]

Definition at line 119 of file domain_multiscale.h.

---

Member Data Documentation

Communicator* DomainMultiScale::communicateur [private]

global communicator object used to perform all communications

Definition at line 145 of file domain_multiscale.h.

Referenced by build(), getCommunicator(), ParseLine(), SaveSituation(), Update(), UpdateForces(), UpdatePositions(), UpdateVelocities(), and ~DomainMultiScale().

unsigned int DomainMultiScale::Dim [private]

dimension of the multiscale material (should be unified)

Definition at line 139 of file domain_multiscale.h.

Referenced by build(), and ParseLine().

std::map<int,int> DomainMultiScale::dom_group [private]

mapping between IDs and communication group IDs

Definition at line 129 of file domain_multiscale.h.

Referenced by ParseLine(), SaveSituation(), Update(), UpdateForces(), UpdatePositions(), and UpdateVelocities().

std::vector<int> DomainMultiScale::dom_indexes [private]

mapping between IDs and registered order

Definition at line 132 of file domain_multiscale.h.

Referenced by build_indexes(), model(), and ~DomainMultiScale().

std::map<int, DomainInterface *> DomainMultiScale::dom_tab [private]

mapping between IDs and models

Definition at line 127 of file domain_multiscale.h.

Referenced by build_indexes(), model(), nb_models(), ParseLine(), SaveSituation(), Update(), UpdateForces(), UpdatePositions(), UpdateVelocities(), and ~DomainMultiScale().

DumperMultiScale* DomainMultiScale::dumper [private]

global dumper object used to perform any dump of the multiscale material

Definition at line 148 of file domain_multiscale.h.

Referenced by build(), DomainMultiScale(), getDumper(), ParseLine(), and ~DomainMultiScale().

StimulationMultiScale* DomainMultiScale::init_stimulation [private]

stimulations of the multiscale material performed before initial step

Definition at line 150 of file domain_multiscale.h.

Referenced by build(), DomainMultiScale(), ParseLine(), and ~DomainMultiScale().

unsigned int DomainMultiScale::multi_step [private]

notificator of the multitimestep (not used at present time)

Definition at line 137 of file domain_multiscale.h.

Referenced by DomainMultiScale().

char DomainMultiScale::my_config[256] [private]

global config file

Definition at line 142 of file domain_multiscale.h.

Referenced by build(), and ParseLine().

StimulationMultiScale* DomainMultiScale::permanent_stimulation [private]

stabilisation of Melh that need to be used at each timestep

Definition at line 152 of file domain_multiscale.h.

Referenced by ParseLine(), UpdateForces(), and ~DomainMultiScale().

std::vector<BridgingInterface *> DomainMultiScale::rec_tab [private]

vector of registered bridged zones

Definition at line 134 of file domain_multiscale.h.

Referenced by ParseLine(), Update(), UpdateStuck(), and ~DomainMultiScale().

---

The documentation for this class was generated from the following files:

• amel/domain_multiscale.h
• amel/domain_multiscale.cpp

---