Exemple #1
0
/* construct extracting dimensions from the name */
MatrixParameterT::MatrixParameterT(const StringT& name_NxM, char variable):
	ParameterInterfaceT(name_NxM),
	fVariable(variable),
	fCopySymmetric(false)
{
	const char caller[] = "MatrixParameterT::MatrixParameterT";
	const char msg[] = "could not extract %s dimensions from \"%s\" in \"%s\"";

	/* resolve suffix */
	StringT suffix;
	suffix.Suffix(name_NxM, '_');
	if (suffix.StringLength() < 4)
		ExceptionT::GeneralFail(caller, msg, "matrix", suffix.Pointer(), name_NxM.Pointer());
	
	/* resolve column dimensions */
	StringT num;
	num.Suffix(suffix, 'x');
	if (num.StringLength() < 2 || !isdigit(num[1]))
		ExceptionT::GeneralFail(caller, msg, "col", num.Pointer(), name_NxM.Pointer());
	int col = -1;
	col = atoi(num.Pointer(1));
	if (col < 0)
		ExceptionT::GeneralFail(caller, msg, "col", num.Pointer(), name_NxM.Pointer());
	
	/* resolve row dimensions */
	suffix.Root('x');
	if (suffix.StringLength() < 2 || !isdigit(suffix[1]))
		ExceptionT::GeneralFail(caller, msg, "row", suffix.Pointer(), name_NxM.Pointer());
	int row = -1;
	row = atoi(suffix.Pointer(1));
	if (row < 0)
		ExceptionT::GeneralFail(caller, msg, "row", suffix.Pointer(), name_NxM.Pointer());
	
	/* initialize */
	fMatrix.Dimension(row, col);
	fMatrix = 0.0;
}
Exemple #2
0
/* construct extracting length from the name */
VectorParameterT::VectorParameterT(const StringT& name_N, char variable):
	ParameterInterfaceT(name_N),
	fVariable(variable)
{
	const char caller[] = "VectorParameterT::VectorParameterT";
	const char msg[] = "could not extract length from \"%s\" in \"%s\"";

	/* resolve length */
	StringT suffix;
	suffix.Suffix(name_N, '_');
	if (suffix.StringLength() < 2 || !isdigit(suffix[1]))
		ExceptionT::GeneralFail(caller, msg, suffix.Pointer(), name_N.Pointer());
	int length = -1;
	length = atoi(suffix.Pointer(1));
	if (length < 0) 
		ExceptionT::GeneralFail(caller, msg, suffix.Pointer(), name_N.Pointer());

	/* initialize */
	fVector.Dimension(length);
	fVector = 0.0;
}
Exemple #3
0
bool TextInputT::Open (const StringT& filename)
{
  /* create file root */
  StringT suffix;
  suffix.Suffix (filename.Pointer());
  if (strncmp (suffix.Pointer(), ".geo", 4) == 0 ||
      strncmp (suffix.Pointer(), ".run", 4) == 0 ||
      strncmp (suffix.Pointer(), ".in", 3) == 0)
  fFileRoot.Root (filename);
  fFilePath.FilePath(fFileRoot);

	/* scan geometry file */
	ifstreamT geo;
	if (!OpenFile (geo, ".geo")) {
		cout << "\n TextInputT::Open: error opening geometry file: " << geo.filename() << endl;
		return false;
	}
	if (!ScanGeometryFile (geo)) {
		cout << "\n TextInputT::Open: error scanning geometry file: " << geo.filename() << endl;
		return false;
	}

	/* scan results file */
	ifstreamT run;
	if (!OpenFile (run, ".run")) {
		cout << "\n TextInputT::Open: error opening results file: " << run.filename() << endl;
		return false;
	}
    if (!ScanResultsFile (run)) {
		cout << "\n TextInputT::Open: error scanning results file: " << run.filename() << endl;
		return false;
    }
      
	/* must be OK */
	return true;
}
/* 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;   }
        }
}