/* Batch file processing */
void ExecutionManagerT::RunBatch(ifstreamT& in, ostream& status)
{
/* mark status */
status << "\n Processing batch file: " << in.filename() << '\n';
/* start day/date info */
time_t starttime;
time(&starttime);
/* get 1st entry */
StringT nextinfilename;
in >> nextinfilename;
/* repeat to end of file */
while (in.good())
{
/* adjusting execution options */
if (nextinfilename[0] == '-')
AddCommandLineOption(nextinfilename);
else /* execute regular file */
{
/* file path format */
nextinfilename.ToNativePathName();
/* path to source file */
StringT path;
path.FilePath(in.filename());
/* open new input stream */
nextinfilename.Prepend(path);
ifstreamT nextin('#', nextinfilename);
/* process if valid */
if (nextin.is_open())
JobOrBatch(nextin, cout);
else
cout << " File not found: " << nextinfilename << '\n';
}
/* get next entry */
in >> nextinfilename;
}
/* stop day/date info */
time_t stoptime;
time(&stoptime);
cout << "\n Batch start time : " << ctime(&starttime);
cout << " Batch stop time : " << ctime(&stoptime);
}
EVPFDBaseT::EVPFDBaseT(ifstreamT& in, const FSMatSupportT& support) :
ParameterInterfaceT("EVPFDBase"),
// FDHookeanMatT(in, support),
IsotropicT (in),
//fdt (element.FEManager().TimeStep()),
//ftime (element.ElementSupport().Time()),
//fStatus (element.RunState()),
fLocDisp (support.LocalArray(LocalArrayT::kDisp)),
fLocLastDisp(support.LocalArray(LocalArrayT::kLastDisp)),
fKineticEqn (NULL),
fSolver (NULL),
fSolverPtr (new SolverWrapperEVPBase(*this)),
fFtot (kNSD),
fs_ij (kNSD),
fc_ijkl (dSymMatrixT::NumValues(kNSD))
{
ExceptionT::GeneralFail("EVPFDBaseT::EVPFDBaseT", "out of date");
// input file
StringT filename;
in >> filename;
// generate relative path in native format
filename.ToNativePathName();
StringT path;
path.FilePath(in.filename());
filename.Prepend(path);
OpenExternal(fInput, filename, "EVPFDBaseT data");
if (in.skip_comments())
fInput.set_marker(in.comment_marker());
// Lame's constants
fmu = Mu();
flambda = Lambda();
fbulk = flambda + 2./3.*fmu;
}
/* accept parameter list */
void ThermomechanicalCouplingManagerT::TakeParameterList(const ParameterListT& list)
{
const char caller[] = "ThermomechanicalCouplingManagerT::TakeParameterList";
/* inherited */
// MultiManagerT::TakeParameterList(list);
/* inherited - don't call direct base class method */
ParameterInterfaceT::TakeParameterList(list);
/* path to parameters file */
StringT path;
path.FilePath(fInputFile);
TaskT task = kRun;
/* parse/validate continuum input */
StringT continuum_input = list.GetParameter("continuum_input");
continuum_input.ToNativePathName();
continuum_input.Prepend(path);
ParameterListT continuum_params;
ParseInput(continuum_input, continuum_params, true, true, true, fArgv);
/* construct continuum solver */
if (fCoarseComm->Size() != 1)
ExceptionT::GeneralFail(caller, "parallel execution error");
if (Size() > 1) /* change file name so output files are unique */ {
StringT suffix;
suffix.Suffix(continuum_input);
continuum_input.Root();
continuum_input.Append(".p", Rank());
continuum_input.Append(suffix);
}
StringT continuum_output_file;
continuum_output_file.Root(continuum_input);
continuum_output_file.Append(".out");
fCoarseOut.open(continuum_output_file);
fCoarse = TB_DYNAMIC_CAST(FEManagerT_bridging*, FEManagerT::New(continuum_params.Name(), continuum_input, fCoarseOut, *fCoarseComm, fArgv, task));
if (!fCoarse) ExceptionT::GeneralFail(caller, "could not construct continuum solver");
fCoarse->TakeParameterList(continuum_params);
/* parse/validate atomistic input */
StringT atom_input = list.GetParameter("atom_input");
atom_input.ToNativePathName();
atom_input.Prepend(path);
ParameterListT atom_params;
ParseInput(atom_input, atom_params, true, true, true, fArgv);
/* construct atomistic solver */
if (Size() != fFineComm->Size())
ExceptionT::GeneralFail(caller, "parallel execution error");
StringT atom_output_file;
atom_output_file.Root(atom_input);
if (Size() > 1) atom_output_file.Append(".p", Rank());
atom_output_file.Append(".out");
fFineOut.open(atom_output_file);
fFine = TB_DYNAMIC_CAST(FEManagerT_bridging*, FEManagerT::New(atom_params.Name(), atom_input, fFineOut, *fFineComm, fArgv, task));
if (!fFine) ExceptionT::GeneralFail(caller, "could not construct atomistic solver");
fFine->TakeParameterList(atom_params);
/* check consistency between time managers */
TimeManagerT* atom_time = fFine->TimeManager();
TimeManagerT* continuum_time = fCoarse->TimeManager();
/* use parameters from coarse scale solver */
fTimeManager = fCoarse->TimeManager();
fOutputFormat = fCoarse->OutputFormat();
/* don't compute initial conditions */
fFine->SetComputeInitialCondition(false);
fCoarse->SetComputeInitialCondition(false);
/* resolve bridging fields */
const StringT& bridging_field = list.GetParameter("bridging_field");
fFineField = fFine->NodeManager()->Field(bridging_field);
if (!fFineField) ExceptionT::GeneralFail(caller, "could not resolve fine scale \"%s\" field", bridging_field.Pointer());
fCoarseField = fCoarse->NodeManager()->Field(bridging_field);
if (!fFineField) ExceptionT::GeneralFail(caller, "could not resolve coarse scale \"%s\" field", bridging_field.Pointer());
/* resolve integrator types */
// if (fFineField->Integrator().ImplicitExplicit() != fCoarseField->Integrator().ImplicitExplicit())
// ExceptionT::GeneralFail(caller, "time integrator mismatch");
fImpExp = fFineField->Integrator().ImplicitExplicit();
/* collect the ghost atom ID list */
ArrayT<StringT> ghost_atom_ID;
const ParameterListT* ghosts = list.List("ghost_atom_ID_list");
if (ghosts) StringListT::Extract(*ghosts, ghost_atom_ID);
/* configure projection/interpolation */
NodeManagerT& fine_node_manager = *(fFine->NodeManager());
int group = 0;
int order1 = 0;
bool make_inactive = true;
bool node_to_node = false;
fFine->InitGhostNodes(fFineField->FieldName(), ghost_atom_ID, fCoarse->ProjectImagePoints());
fCoarse->InitInterpolation(fFineField->FieldName(), fFine->GhostNodes(), fine_node_manager.InitialCoordinates());
fCoarse->InitProjection(fFineField->FieldName(), *(fFine->CommManager()), fFine->NonGhostNodes(), fine_node_manager, make_inactive, node_to_node);
/* send coarse/fine output through the fFine output */
int ndof = fFine->NodeManager()->NumDOF(group);
ArrayT<StringT> labels(2*ndof);
const char* coarse_labels[] = {"UC_X", "UC_Y", "UC_Z"};
const char* fine_labels[] = {"UF_X", "UF_Y", "UF_Z"};
int dex = 0;
for (int i = 0; i < ndof; i++) labels[dex++] = coarse_labels[i];
for (int i = 0; i < ndof; i++) labels[dex++] = fine_labels[i];
const iArrayT& non_ghost_nodes = fFine->NonGhostNodes();
fAtomConnectivities.Alias(non_ghost_nodes.Length(), 1, non_ghost_nodes.Pointer());
OutputSetT output_set(GeometryT::kPoint, fAtomConnectivities, labels, false);
fOutputID = fFine->RegisterOutput(output_set);
/* construct solver */
int n1 = fFine->NumGroups();
int n2 = fCoarse->NumGroups();
// if (n1 != n2) ExceptionT::GeneralFail(caller, "number of groups must match: %d != %d", n1, n2);
const ParameterListT* multi_solver = list.ListChoice(*this, "multi_solver_choice");
if (multi_solver)
{
/* construct */
SolverT* solver = SolverT::New(*this, multi_solver->Name(), 0);
if (!solver) ExceptionT::GeneralFail(caller, "could not construct solver \"%s\"",
multi_solver->Name().Pointer());
solver->TakeParameterList(*multi_solver);
/* store */
fSolvers.Dimension(1);
fSolvers[0] = solver;
}
SetSolver();
/* default solver phases */
fMaxSolverLoops = 1;
fSolverPhases.Dimension(1, 3);
fSolverPhases(0,0) = 0;
fSolverPhases(0,1) =-1;
fSolverPhases(0,2) =-1;
fSolverPhasesStatus.Dimension(fSolverPhases.MajorDim(), kNumStatusFlags);
fSolverPhasesStatus = 0;
/* terms to include in the equilibrium equations */
fFineToCoarse = list.GetParameter("fine_to_coarse");
fCoarseToFine = list.GetParameter("coarse_to_fine");
if (fCoarseToFine) /* enforce zero bond density in projected cells */
fCoarse->DeactivateFollowerCells();
/* needed to solve overlap */
const dArray2DT& fine_init_coords = fine_node_manager.InitialCoordinates();
const ParticlePairT* particle_pair = fFine->ParticlePair();
if (!particle_pair) ExceptionT::GeneralFail(caller, "could not resolve ParticlePairT");
/* overlap correction method */
StringT overlap_path;
const ParameterT* overlap_file = list.Parameter("overlap_file");
if (overlap_file) {
overlap_path = *overlap_file;
overlap_path.ToNativePathName();
StringT path;
path.FilePath(fInputFile);
overlap_path.Prepend(path);
} /* default name */
else {
overlap_path.Root(fInputFile);
overlap_path.Append(".overlap");
}
const ParameterListT& overlap = list.GetListChoice(*this, "overlap_correction_choice");
if (overlap.Name() == "prescribe_overlap")
{
double density = overlap.GetParameter("bond_density");
cout << "\n " << caller << ": \"prescribe_overlap\" not implemented. p = 1.0" << endl;
}
else if (overlap.Name() == "by-bond_multiplier")
{
/* extract parameters */
double smoothing = overlap.GetParameter("smoothing");
double bind_1 = overlap.GetParameter("bind_to_1.0");
double reg = overlap.GetParameter("constraint_regularization");
int nip = overlap.GetParameter("density_nip");
double init_bound_width = overlap.GetParameter("init_bound_width");
/* compute overlap correction */
double bound_0 = init_bound_width/2.0;
fCoarse->CorrectOverlap_2(particle_pair->Neighbors(), fine_init_coords,
overlap_path, smoothing, bind_1, reg, bound_0, nip);
}
else if (overlap.Name() == "by-bond_penalty")
{
/* extract parameters */
double smoothing = overlap.GetParameter("smoothing");
double bind_1 = overlap.GetParameter("bind_to_1.0");
double bound_tol = overlap.GetParameter("bound_tolerance");
double stiffness_jump = overlap.GetParameter("stiffness_jump");
int nip = overlap.GetParameter("density_nip");
/* compute overlap correction */
fCoarse->CorrectOverlap_22(particle_pair->Neighbors(), fine_init_coords,
overlap_path, smoothing, bind_1, bound_tol, stiffness_jump, nip);
}
else
ExceptionT::GeneralFail(caller, "unrecognized overlap correction method \"%s\"",
overlap.Name().Pointer());
/* output for kinetic temperature */
ModelManagerT* model = fCoarse->ModelManager();
ArrayT<StringT> vlabels(1);
const char* label[] = {"kT"};
vlabels[0] = label[0];
/* specify output - "free set" */
const char* id = "1";
StringT ID ; // HACK
ID = fCoarse->ElementGroup(0)->ElementBlockID(1);
OutputSetT coarse_output_set(model->ElementGroupGeometry(ID), model->ElementGroup(ID), vlabels);
fCoarseOutputID = fCoarse->RegisterOutput(coarse_output_set);
/* find particle class */
for (int i = 0; i < fFine->NumElementGroups(); i++)
{
ElementBaseT* element_base = fFine->ElementGroup(i);
ParticleT* particle = dynamic_cast<ParticleT*>(element_base);
if (particle) { fParticles = particle; }
}
}
/* accept parameter list */
void ABAQUS_UMAT_SS_BaseT::TakeParameterList(const ParameterListT& list)
{
const char caller[] = "ABAQUS_UMAT_SS_BaseT::TakeParameterList";
/* inherited */
SSIsotropicMatT::TakeParameterList(list);
fDebug = list.GetParameter("debug");
fUseUMATModulus = list.GetParameter("use_UMAT_modulus");
fNumElasticIterations = list.GetParameter("elastic_iterations");
/* dimension work space */
int nsd = NumSD();
fStress.Dimension(nsd);
fIPCoordinates.Dimension(nsd);
fmat_nsd.Dimension(nsd);
fsym_mat_nsd.Dimension(dSymMatrixT::int2DimensionT(nsd));
/* open UMAT parameters file */
StringT path;
path.FilePath(MaterialSupport().InputFile());
StringT params = list.GetParameter("UMAT_parameter_file");
params.ToNativePathName();
params.Prepend(path);
ifstreamT in('#', params);
if (!in.is_open())
ExceptionT::GeneralFail(caller, "could not open file \"%s\"",
params.Pointer());
/* read ABAQUS-format input */
bool nonsym = false;
Read_ABAQUS_Input(in, fUMAT_name, fProperties, fDensity, nstatv, nonsym);
if (nonsym)
fTangentType = GlobalT::kNonSymmetric;
/* notify */
if (fThermal->IsActive())
cout << "\n ABAQUS_UMAT_SS_BaseT::Initialize: thermal strains must\n"
<< " be handled within the UMAT\n" << endl;
/* UMAT dimensions */
ndi = 3; // always 3 direct components
if (nsd == 2)
nshr = 1;
else if (nsd == 3)
nshr = 3;
else
ExceptionT::GeneralFail(caller, "unexpected dimension %d", nsd);
ntens = ndi + nshr;
/* modulus storage */
if (fTangentType == GlobalT::kDiagonal)
fModulusDim = ntens;
else if (fTangentType == GlobalT::kSymmetric)
{
if (nsd == 2) fModulusDim = 10;
else if (nsd == 3) fModulusDim = 21;
else ExceptionT::GeneralFail(caller);
}
else if (fTangentType == GlobalT::kNonSymmetric)
fModulusDim = ntens*ntens;
else
ExceptionT::GeneralFail(caller);
/* storage block size (per ip) */
fBlockSize = 0;
fBlockSize += ntens; // fstress
fBlockSize += ntens; // fstrain
fBlockSize += 3; // fsse_pd_cd
fBlockSize += nstatv; // fstatv
fBlockSize += fModulusDim; // fmodulus
fBlockSize += ntens; // fstress_last
fBlockSize += ntens; // fstrain_last
fBlockSize += 3; // fsse_pd_cd_last
fBlockSize += nstatv; // fstatv_last
/* argument array */
fArgsArray.Dimension(fBlockSize);
/* assign pointers */
doublereal* parg = fArgsArray.Pointer();
fstress.Set(ntens, parg); parg += ntens;
fstrain.Set(ntens, parg); parg += ntens;
fsse_pd_cd.Set(3, parg); parg += 3;
fstatv.Set(nstatv, parg); parg += nstatv;
fmodulus.Set(fModulusDim, parg); parg += fModulusDim;
fstress_last.Set(ntens, parg); parg += ntens;
fstrain_last.Set(ntens, parg); parg += ntens;
fsse_pd_cd_last.Set(3, parg); parg += 3;
fstatv_last.Set(nstatv, parg);
/* UMAT array arguments */
fddsdde.Dimension(ntens);
fddsdde = 0.0;
fdstran.Dimension(ntens);
fdstran = 0.0;
fdrot.Dimension(3); // always 3
fdrot.Identity();
fdfgrd0.Dimension(3); // always 3
fdfgrd0.Identity();
fdfgrd1.Dimension(3); // always 3
fdfgrd1.Identity();
fcoords.Dimension(nsd);
/* write properties */
ofstreamT& out = MaterialSupport().Output();
out << " Number of ABAQUS UMAT internal variables. . . . = " << nstatv << '\n';
out << " Number of ABAQUS UMAT properties. . . . . . . . = " << fProperties.Length() << '\n';
PrintProperties(out);
/* set material output variables/labels */
SetOutputVariables(fOutputIndex, fOutputLabels);
}